@dmptool/types 1.0.0 → 1.0.1

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dateQuestions_1 = require("../dateQuestions");
+describe("DatePickerQuestion", () => {
+    it("should validate a valid DatePickerQuestion object", () => {
+        const validDatePicker = {
+            type: "datePicker",
+            attributes: {
+                max: "2023-12-31",
+                min: "2023-01-01",
+                step: 1,
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => dateQuestions_1.DatePickerQuestion.parse(validDatePicker)).not.toThrow();
+    });
+    it("should throw an error for an invalid DatePickerQuestion object", () => {
+        const invalidDatePicker = {
+            type: "datePicker",
+            attributes: {
+                max: 123, // Invalid type for max
+                min: "2023-01-01",
+                step: "one", // Invalid type for step
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => dateQuestions_1.DatePickerQuestion.parse(invalidDatePicker)).toThrow();
+    });
+    it("should allow optional attributes in DatePickerQuestion", () => {
+        const validDatePicker = {
+            type: "datePicker",
+            attributes: {},
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => dateQuestions_1.DatePickerQuestion.parse(validDatePicker)).not.toThrow();
+    });
+});
+describe("DateRangeQuestion", () => {
+    it("should validate a valid DateRangeQuestion object", () => {
+        const validDateRange = {
+            type: "dateRange",
+            columns: {
+                start: {
+                    type: "datePicker",
+                    attributes: {
+                        label: "Start Date",
+                        max: "2023-12-31",
+                        min: "2023-01-01",
+                        step: 1,
+                    },
+                    meta: {
+                        schemaVersion: "1.0"
+                    }
+                },
+                end: {
+                    type: "datePicker",
+                    attributes: {
+                        label: "End Date",
+                        max: "2023-12-31",
+                        min: "2023-01-01",
+                        step: 1,
+                    },
+                    meta: {
+                        schemaVersion: "1.0"
+                    }
+                },
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => dateQuestions_1.DateRangeQuestion.parse(validDateRange)).not.toThrow();
+    });
+    it("should throw an error for an invalid DateRangeQuestion object", () => {
+        const invalidDateRange = {
+            type: "dateRange",
+            columns: {
+                start: {
+                    type: "datePicker",
+                    attributes: {
+                        label: "Start Date",
+                        max: "2023-12-31",
+                        min: "2023-01-01",
+                        step: 1,
+                    },
+                    meta: {
+                        schemaVersion: "1.0"
+                    }
+                },
+                end: {
+                    type: "datePicker",
+                    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.DateRangeQuestion.parse(invalidDateRange)).toThrow();
+    });
+    it("should require labels for start and end date pickers", () => {
+        const invalidDateRange = {
+            type: "dateRange",
+            columns: {
+                start: {
+                    type: "datePicker",
+                    attributes: {
+                        max: "2023-12-31",
+                        min: "2023-01-01",
+                        step: 1,
+                    },
+                    meta: {
+                        schemaVersion: "1.0"
+                    }
+                },
+                end: {
+                    type: "datePicker",
+                    attributes: {
+                        label: "End Date",
+                        max: "2023-12-31",
+                        min: "2023-01-01",
+                        step: 1,
+                    },
+                    meta: {
+                        schemaVersion: "1.0"
+                    }
+                },
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => dateQuestions_1.DateRangeQuestion.parse(invalidDateRange)).toThrow();
+    });
+});

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

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

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const graphQLQuestions_1 = require("../graphQLQuestions");
+(0, globals_1.describe)("FilteredSearchQuestion schema", () => {
+    (0, globals_1.it)("should validate a correct FilteredSearchQuestion object", () => {
+        const validData = {
+            type: "filteredSearch",
+            graphQL: {
+                displayFields: [
+                    { propertyName: "name", label: "Name" },
+                    { propertyName: "age", label: "Age", labelTranslationKey: "age_key" },
+                ],
+                query: "query($searchTerm: String!, $minAge: Int!) { users(searchTerm: $searchTerm, minAge: $minAge) { name age } }",
+                responseField: "data",
+                variables: [
+                    { name: "searchTerm", type: "string", defaultValue: "default" },
+                    { name: "minAge", type: "number", minLength: 1 },
+                ],
+            },
+            attributes: {
+                multiple: true,
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.FilteredSearchQuestion.parse(validData)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid FilteredSearchQuestion object", () => {
+        const invalidData = {
+            type: "filteredSearch",
+            graphQL: {
+                displayFields: [
+                    { propertyName: "name", label: "Name" },
+                ],
+                responseField: "data",
+                variables: [
+                    { name: "searchTerm", type: "string" },
+                ],
+            },
+            attributes: {
+                multiple: "notABoolean", // Invalid type
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.FilteredSearchQuestion.parse(invalidData)).toThrow();
+    });
+});
+(0, globals_1.describe)("TypeaheadSearchQuestion schema", () => {
+    (0, globals_1.it)("should validate a correct TypeaheadSearchQuestion object", () => {
+        const validData = {
+            type: "typeaheadSearch",
+            graphQL: {
+                displayFields: [
+                    { propertyName: "title", label: "Title" },
+                ],
+                localQueryId: "12345",
+                responseField: "results",
+                variables: [
+                    { name: "query", type: "string" },
+                ],
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.TypeaheadSearchQuestion.parse(validData)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid TypeaheadSearchQuestion object", () => {
+        const invalidData = {
+            type: "typeaheadSearch",
+            graphQL: {
+                displayFields: [
+                    { propertyName: "title", label: "Title" },
+                ],
+                responseField: "results",
+                variables: [
+                    { name: "query", type: 123 }, // Invalid type
+                ],
+            },
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.TypeaheadSearchQuestion.parse(invalidData)).toThrow();
+    });
+});

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

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

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const optionBasedQuestions_1 = require("../optionBasedQuestions");
+(0, globals_1.describe)("CheckboxesQuestion", () => {
+    (0, globals_1.it)("should validate a valid CheckboxesQuestion object", () => {
+        const validCheckboxesQuestion = {
+            type: "checkBoxes",
+            options: [
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Apple",
+                        value: "apple",
+                        checked: true,
+                    },
+                },
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Banana",
+                        value: "banana",
+                    },
+                },
+            ],
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.CheckboxesQuestion.parse(validCheckboxesQuestion)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid CheckboxesQuestion object", () => {
+        const invalidCheckboxesQuestion = {
+            type: "checkBoxes",
+            options: [
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Apple",
+                        value: "apple",
+                        checked: "true", // Invalid type for checked
+                    },
+                },
+            ],
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.CheckboxesQuestion.parse(invalidCheckboxesQuestion)).toThrow();
+    });
+});
+(0, globals_1.describe)("RadioButtonsQuestion", () => {
+    (0, globals_1.it)("should validate a valid RadioButtonsQuestion object", () => {
+        const validRadioButtonsQuestion = {
+            type: "radioButtons",
+            options: [
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Male",
+                        value: "male",
+                        selected: true,
+                    },
+                },
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Female",
+                        value: "female",
+                    },
+                },
+            ],
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.RadioButtonsQuestion.parse(validRadioButtonsQuestion)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid RadioButtonsQuestion object", () => {
+        const invalidRadioButtonsQuestion = {
+            type: "radioButtons",
+            options: [
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Male",
+                        value: "male",
+                        selected: "true", // Invalid type for selected
+                    },
+                },
+            ],
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.RadioButtonsQuestion.parse(invalidRadioButtonsQuestion)).toThrow();
+    });
+});
+(0, globals_1.describe)("SelectBoxQuestion", () => {
+    (0, globals_1.it)("should validate a valid SelectBoxQuestion object", () => {
+        const validSelectBoxQuestion = {
+            type: "selectBox",
+            options: [
+                {
+                    type: "option",
+                    attributes: {
+                        label: "USA",
+                        value: "usa",
+                        selected: true,
+                    },
+                },
+                {
+                    type: "option",
+                    attributes: {
+                        label: "Canada",
+                        value: "canada",
+                    },
+                },
+            ],
+            attributes: {
+                multiple: true,
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.SelectBoxQuestion.parse(validSelectBoxQuestion)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid SelectBoxQuestion object", () => {
+        const invalidSelectBoxQuestion = {
+            type: "selectBox",
+            questionText: "Select your country",
+            options: [
+                {
+                    type: "option",
+                    attributes: {
+                        label: "USA",
+                        value: "usa",
+                        selected: "true", // Invalid type for selected
+                    },
+                },
+            ],
+            attributes: {
+                multiple: "true", // Invalid type for multiple
+            },
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        (0, globals_1.expect)(() => optionBasedQuestions_1.SelectBoxQuestion.parse(invalidSelectBoxQuestion)).toThrow();
+    });
+});

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

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

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const primitiveQuestions_1 = require("../primitiveQuestions");
+describe("Primitive Questions Zod Schemas", () => {
+    it("should validate a valid BooleanQuestion", () => {
+        const validBooleanQuestion = {
+            type: "boolean",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                checked: true,
+            },
+        };
+        expect(() => primitiveQuestions_1.BooleanQuestion.parse(validBooleanQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid BooleanQuestion", () => {
+        const invalidBooleanQuestion = {
+            type: "boolean",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                checked: "true", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.BooleanQuestion.parse(invalidBooleanQuestion)).toThrow();
+    });
+    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(() => primitiveQuestions_1.CurrencyQuestion.parse(validCurrencyQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid CurrencyQuestion", () => {
+        const invalidCurrencyQuestion = {
+            type: "currency",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                max: "100", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.CurrencyQuestion.parse(invalidCurrencyQuestion)).toThrow();
+    });
+    it("should validate a valid EmailQuestion", () => {
+        const validEmailQuestion = {
+            type: "email",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: 50,
+                minLength: 5,
+                multiple: true,
+                pattern: "^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$",
+            },
+        };
+        expect(() => primitiveQuestions_1.EmailQuestion.parse(validEmailQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid EmailQuestion", () => {
+        const invalidEmailQuestion = {
+            type: "email",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: "50", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.EmailQuestion.parse(invalidEmailQuestion)).toThrow();
+    });
+    it("should validate a valid NumberQuestion", () => {
+        const validNumberQuestion = {
+            type: "number",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                max: 100,
+                min: 0,
+                step: 1,
+            },
+        };
+        expect(() => primitiveQuestions_1.NumberQuestion.parse(validNumberQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid NumberQuestion", () => {
+        const invalidNumberQuestion = {
+            type: "number",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                step: "1", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.NumberQuestion.parse(invalidNumberQuestion)).toThrow();
+    });
+    it("should validate a valid TextAreaQuestion", () => {
+        const validTextAreaQuestion = {
+            type: "textArea",
+            meta: {
+                schemaVersion: "1.0",
+                asRichText: true,
+            },
+            attributes: {
+                cols: 30,
+                rows: 5,
+                maxLength: 500,
+                minLength: 10,
+            },
+        };
+        expect(() => primitiveQuestions_1.TextAreaQuestion.parse(validTextAreaQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid TextAreaQuestion", () => {
+        const invalidTextAreaQuestion = {
+            type: "textArea",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                cols: "30", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.TextAreaQuestion.parse(invalidTextAreaQuestion)).toThrow();
+    });
+    it("should validate a valid TextQuestion", () => {
+        const validTextQuestion = {
+            type: "text",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: 100,
+                minLength: 1,
+                pattern: "^[a-zA-Z]+$",
+            },
+        };
+        expect(() => primitiveQuestions_1.TextQuestion.parse(validTextQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid TextQuestion", () => {
+        const invalidTextQuestion = {
+            type: "text",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: "100", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.TextQuestion.parse(invalidTextQuestion)).toThrow();
+    });
+    it("should validate a valid URLQuestion", () => {
+        const validURLQuestion = {
+            type: "url",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: 200,
+                minLength: 10,
+                pattern: "https?://.+",
+            },
+        };
+        expect(() => primitiveQuestions_1.URLQuestion.parse(validURLQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid URLQuestion", () => {
+        const invalidURLQuestion = {
+            type: "url",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                maxLength: "200", // Invalid type
+            },
+        };
+        expect(() => primitiveQuestions_1.URLQuestion.parse(invalidURLQuestion)).toThrow();
+    });
+});

package/dist/{dateQuestions.js → questions/dateQuestions.js}

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DateRangeQuestion = exports.DatePickerQuestion = void 0;
 const zod_1 = require("zod");
-const primitiveQuestions_1 = require("./primitiveQuestions");
+const question_1 = require("./question");
 // Date picker question and answer
-exports.DatePickerQuestion = primitiveQuestions_1.Question.merge(zod_1.z.object({
+exports.DatePickerQuestion = question_1.Question.merge(zod_1.z.object({
     type: zod_1.z.literal('datePicker'), // The type of question
     attributes: zod_1.z.object({
         max: zod_1.z.string().optional(), // The maximum date (no default)
@@ -13,7 +13,7 @@ exports.DatePickerQuestion = primitiveQuestions_1.Question.merge(zod_1.z.object(
     })
 }));
 // Date range question and answer
-exports.DateRangeQuestion = primitiveQuestions_1.Question.merge(zod_1.z.object({
+exports.DateRangeQuestion = question_1.Question.merge(zod_1.z.object({
     type: zod_1.z.literal('dateRange'), // The type of question
     columns: zod_1.z.object({
         start: exports.DatePickerQuestion.merge(zod_1.z.object({

package/dist/{graphQLQuestions.js → questions/graphQLQuestions.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeaheadSearchQuestion = exports.FilteredSearchQuestion = void 0;
 const zod_1 = require("zod");
-const primitiveQuestions_1 = require("./primitiveQuestions");
+const question_1 = require("./question");
 // An input variable for a GraphQL query
 const GraphQLVariable = zod_1.z.object({
     minLength: zod_1.z.number().optional(), // A min length for the variable before executing the query
@@ -27,7 +27,7 @@ const GraphQLQuery = zod_1.z.object({
     variables: zod_1.z.array(GraphQLVariable) // The variables for the query
 });
 // Filtered search question and answer
-exports.FilteredSearchQuestion = primitiveQuestions_1.Question.merge(zod_1.z.object({
+exports.FilteredSearchQuestion = question_1.Question.merge(zod_1.z.object({
     type: zod_1.z.literal('filteredSearch'), // The type of question
     graphQL: GraphQLQuery, // The GraphQL query options for the filtered search
     attributes: zod_1.z.object({
@@ -35,7 +35,7 @@ exports.FilteredSearchQuestion = primitiveQuestions_1.Question.merge(zod_1.z.obj
     })
 }));
 // Typeahead search question and answer
-exports.TypeaheadSearchQuestion = primitiveQuestions_1.Question.merge(zod_1.z.object({
+exports.TypeaheadSearchQuestion = question_1.Question.merge(zod_1.z.object({
     type: zod_1.z.literal('typeaheadSearch'), // The type of question
     graphQL: GraphQLQuery, // The GraphQL query options for the typeahead search
 }));