@dmptool/types 1.2.3 → 1.2.5

package/dist/answers/tableAnswers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableAnswerSchema = exports.TableRowAnswerSchema = exports.AnyTableColumnAnswerSchema = void 0;
+exports.ResearchOutputTableAnswerSchema = exports.TableAnswerSchema = exports.TableRowAnswerSchema = exports.AnyTableColumnAnswerSchema = void 0;
 const zod_1 = require("zod");
 const answer_1 = require("./answer");
 const optionBasedAnswers_1 = require("./optionBasedAnswers");
@@ -18,10 +18,13 @@ exports.AnyTableColumnAnswerSchema = zod_1.z.discriminatedUnion('type', [
     dateAnswers_1.DateAnswerSchema,
     dateAnswers_1.DateRangeAnswerSchema,
     textAnswers_1.EmailAnswerSchema,
-    graphQLAnswers_1.FilteredSearchAnswerSchema,
+    graphQLAnswers_1.LicenseSearchAnswerSchema,
+    graphQLAnswers_1.MetadataStandardSearchAnswerSchema,
     optionBasedAnswers_1.MultiselectBoxAnswerSchema,
     numberAnswers_1.NumberAnswerSchema,
+    numberAnswers_1.NumberWithContextAnswerSchema,
     optionBasedAnswers_1.RadioButtonsAnswerSchema,
+    graphQLAnswers_1.RepositorySearchAnswerSchema,
     optionBasedAnswers_1.SelectBoxAnswerSchema,
     textAnswers_1.TextAnswerSchema,
     textAnswers_1.TextAreaAnswerSchema,
@@ -42,3 +45,61 @@ exports.TableAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
                 }]
         }])
 }));
+exports.ResearchOutputTableAnswerSchema = exports.TableAnswerSchema.merge(zod_1.z.object({
+    type: zod_1.z.literal('researchOutputTable'),
+    columnHeadings: zod_1.z.array(zod_1.z.string()).default(['Title', 'Output Type']),
+    answer: zod_1.z.array(exports.TableRowAnswerSchema).default([{
+            columns: [
+                {
+                    type: 'text',
+                    answer: '',
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'textArea',
+                    answer: '',
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'selectBox',
+                    answer: '',
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'checkBoxes',
+                    answer: [],
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'selectBox',
+                    answer: '',
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'date',
+                    answer: '',
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'numberWithContext',
+                    answer: { value: undefined, context: '' },
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'repositorySearch',
+                    answer: [],
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'metadataStandardSearch',
+                    answer: [],
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                },
+                {
+                    type: 'licenseSearch',
+                    answer: [],
+                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
+                }
+            ]
+        }])
+}));

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

@@ -2,94 +2,232 @@
 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", () => {
+(0, globals_1.describe)("AffiliationSearchQuestion schema", () => {
+    (0, globals_1.it)("should validate a correct AffiliationSearchQuestion object", () => {
         const validData = {
-            type: "filteredSearch",
+            type: "affiliationSearch",
+            attributes: {
+                label: "Search",
+                help: "Search for a institution",
+            },
             graphQL: {
+                query: graphQLQuestions_1.affiliationQuery,
                 displayFields: [
-                    { propertyName: "name", label: "Name" },
-                    { propertyName: "age", label: "Age", labelTranslationKey: "age_key" },
+                    { propertyName: "displayName", label: "Name" },
                 ],
-                query: "query($searchTerm: String!, $minAge: Int!) { users(searchTerm: $searchTerm, minAge: $minAge) { name age } }",
-                responseField: "data",
+                localQueryId: "12345",
+                answerField: "uri",
+                responseField: "affiliations.items",
                 variables: [
-                    { name: "searchTerm", type: "string", defaultValue: "default" },
-                    { name: "minAge", type: "number", minLength: 1 },
+                    { type: "string", name: "name", label: "Term", minLength: 3 },
                 ],
             },
-            attributes: {
-                label: "Search",
-                help: "Search for a user",
-                multiple: true,
-            },
             meta: {
                 schemaVersion: "1.0"
             }
         };
-        (0, globals_1.expect)(() => graphQLQuestions_1.FilteredSearchQuestionSchema.parse(validData)).not.toThrow();
+        (0, globals_1.expect)(() => graphQLQuestions_1.AffiliationSearchQuestionSchema.parse(validData)).not.toThrow();
     });
-    (0, globals_1.it)("should throw an error for an invalid FilteredSearchQuestion object", () => {
+    (0, globals_1.it)("should throw an error for an invalid AffiliationSearchQuestion object", () => {
         const invalidData = {
-            type: "filteredSearch",
+            type: "affiliationSearch",
             graphQL: {
                 displayFields: [
-                    { propertyName: "name", label: "Name" },
+                    { propertyName: "title", label: "Title" },
                 ],
-                responseField: "data",
+                responseField: "results",
                 variables: [
-                    { name: "searchTerm", type: "string" },
+                    { name: "query", type: 123 }, // Invalid type
                 ],
             },
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.AffiliationSearchQuestionSchema.parse(invalidData)).toThrow();
+    });
+});
+(0, globals_1.describe)("LicenseSearchQuestion schema", () => {
+    (0, globals_1.it)("should validate a correct LicenseSearchQuestion object", () => {
+        const validData = {
+            type: "licenseSearch",
             attributes: {
-                multiple: "notABoolean", // Invalid type
+                label: "License Search",
+                help: "Search for a license",
+            },
+            graphQL: {
+                query: "query Licenses($term: String, $paginationOptions: PaginationOptions){ license(term: $term, paginationOptions: $paginationOptions) { totalCount currentOffset limit hasNextPage hasPreviousPage availableSortFields items { id name uri description } } }",
+                displayFields: [
+                    {
+                        propertyName: "name",
+                        label: "Name"
+                    },
+                    {
+                        propertyName: "description",
+                        label: "Description"
+                    },
+                    {
+                        propertyName: "recommended",
+                        label: "Recommended"
+                    }
+                ],
+                answerField: "uri",
+                responseField: "licenses.items",
+                variables: [
+                    {
+                        type: "string",
+                        name: "term",
+                        label: "Search term",
+                        minLength: 2
+                    },
+                ],
             },
             meta: {
                 schemaVersion: "1.0"
             }
         };
-        (0, globals_1.expect)(() => graphQLQuestions_1.FilteredSearchQuestionSchema.parse(invalidData)).toThrow();
+        (0, globals_1.expect)(() => graphQLQuestions_1.LicenseSearchQuestionSchema.parse(validData)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid LicenseSearchQuestion object", () => {
+        const invalidData = {
+            type: "licenseSearch",
+            graphQL: {
+                displayFields: [],
+                query: 'myInvalidQuery { licenses { id name } }',
+                variables: [
+                    {
+                        name: "term",
+                        type: "invalid"
+                    },
+                ],
+            },
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.LicenseSearchQuestionSchema.parse(invalidData)).toThrow();
     });
 });
-(0, globals_1.describe)("AffiliationSearchQuestion schema", () => {
-    (0, globals_1.it)("should validate a correct AffiliationSearchQuestion object", () => {
+(0, globals_1.describe)("MetadataStandardSearchQuestion schema", () => {
+    (0, globals_1.it)("should validate a correct MetadataStandardSearchQuestion object", () => {
         const validData = {
-            type: "affiliationSearch",
+            type: "metadataStandardSearch",
             attributes: {
-                label: "Search",
-                help: "Search for a institution",
+                label: "Metadata Standard Search",
+                help: "Search for a metadata standard",
             },
             graphQL: {
-                query: graphQLQuestions_1.affiliationQuery,
+                query: "query MetadataStandards($term: String, $keywords: [String!], $paginationOptions: PaginationOptions){ metadataStandards(term: $term, keywords: $keywords, paginationOptions: $paginationOptions) { totalCount currentOffset limit hasNextPage hasPreviousPage availableSortFields items { id name uri description keywords } } }",
                 displayFields: [
-                    { propertyName: "displayName", label: "Name" },
+                    {
+                        propertyName: "name",
+                        label: "Name"
+                    },
+                    {
+                        propertyName: "description",
+                        label: "Description"
+                    },
+                    {
+                        propertyName: "website",
+                        label: "Website"
+                    },
+                    {
+                        propertyName: "keywords",
+                        label: "Subject Areas"
+                    }
                 ],
-                localQueryId: "12345",
                 answerField: "uri",
-                responseField: "affiliations.items",
+                responseField: "metadataStandards.items",
                 variables: [
-                    { type: "string", name: "name", label: "Term", minLength: 3 },
+                    {
+                        type: "string",
+                        name: "term",
+                        label: "Search term",
+                        minLength: 2
+                    },
+                    {
+                        type: "string",
+                        name: "keywords",
+                        label: "Subject Areas"
+                    }
                 ],
             },
             meta: {
                 schemaVersion: "1.0"
             }
         };
-        (0, globals_1.expect)(() => graphQLQuestions_1.AffiliationSearchQuestionSchema.parse(validData)).not.toThrow();
+        (0, globals_1.expect)(() => graphQLQuestions_1.MetadataStandardSearchQuestionSchema.parse(validData)).not.toThrow();
     });
-    (0, globals_1.it)("should throw an error for an invalid AffiliationSearchQuestion object", () => {
+    (0, globals_1.it)("should throw an error for an invalid MetadataStandardSearchQuestion object", () => {
         const invalidData = {
-            type: "affiliationSearch",
+            type: "metadataStandardSearch",
+            graphQL: {
+                query: 123,
+                variables: [],
+            },
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.MetadataStandardSearchQuestionSchema.parse(invalidData)).toThrow();
+    });
+});
+(0, globals_1.describe)("RepositorySearchQuestion schema", () => {
+    (0, globals_1.it)("should validate a correct RepositorySearchQuestion object", () => {
+        const validData = {
+            type: "repositorySearch",
+            attributes: {
+                label: "Repository Search",
+                help: "Search for a repository",
+            },
             graphQL: {
+                query: "query Repositories($term: String, $keywords: [String!], $repositoryType: String, $paginationOptions: PaginationOptions){ repositories(term: $term, keywords: $keywords, repositoryType: $repositoryType, paginationOptions: $paginationOptions) { totalCount currentOffset limit hasNextPage hasPreviousPage availableSortFields items { id name uri description website keywords repositoryTypes } } }",
                 displayFields: [
-                    { propertyName: "title", label: "Title" },
+                    {
+                        propertyName: "name",
+                        label: "Name"
+                    },
+                    {
+                        propertyName: "description",
+                        label: "Description"
+                    },
+                    {
+                        propertyName: "website",
+                        label: "Website"
+                    },
+                    {
+                        propertyName: "keywords",
+                        label: "Subject Areas"
+                    }
                 ],
-                responseField: "results",
+                answerField: "uri",
+                responseField: "repositories.items",
                 variables: [
-                    { name: "query", type: 123 }, // Invalid type
+                    {
+                        type: "string",
+                        name: "term",
+                        label: "Search term",
+                        minLength: 2
+                    },
+                    {
+                        type: "string",
+                        name: "repositoryType",
+                        label: "Repository Type"
+                    },
+                    {
+                        type: "string",
+                        name: "keywords",
+                        label: "Subject Areas"
+                    }
                 ],
             },
+            meta: {
+                schemaVersion: "1.0"
+            }
         };
-        (0, globals_1.expect)(() => graphQLQuestions_1.AffiliationSearchQuestionSchema.parse(invalidData)).toThrow();
+        (0, globals_1.expect)(() => graphQLQuestions_1.RepositorySearchQuestionSchema.parse(validData)).not.toThrow();
+    });
+    (0, globals_1.it)("should throw an error for an invalid RepositorySearchQuestion object", () => {
+        const invalidData = {
+            type: "repositorySearch",
+            graphQL: {
+                responseField: 123,
+                variables: [
+                    { type: "unknown" },
+                ],
+            },
+        };
+        (0, globals_1.expect)(() => graphQLQuestions_1.RepositorySearchQuestionSchema.parse(invalidData)).toThrow();
     });
 });

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

@@ -105,4 +105,40 @@ describe("Number Questions Zod Schemas", () => {
         };
         expect(() => numberQuestions_1.NumberRangeQuestionSchema.parse(invalidNumberRangeQuestion)).toThrow();
     });
+    it("should validate a valid NumberWithContext", () => {
+        const validNumberQuestion = {
+            type: "numberWithContext",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                max: 100,
+                min: 0,
+                step: 1,
+                context: [
+                    {
+                        label: "MB (megabytes)",
+                        value: "mb",
+                    },
+                    {
+                        label: "GB (gigabytes)",
+                        value: "gb",
+                    },
+                ]
+            },
+        };
+        expect(() => numberQuestions_1.NumberWithContextQuestionSchema.parse(validNumberQuestion)).not.toThrow();
+    });
+    it("should invalidate an invalid NumberWithContext", () => {
+        const invalidNumberQuestion = {
+            type: "numberWithContext",
+            meta: {
+                schemaVersion: "1.0",
+            },
+            attributes: {
+                step: "1", // Invalid type
+            },
+        };
+        expect(() => numberQuestions_1.NumberWithContextQuestionSchema.parse(invalidNumberQuestion)).toThrow();
+    });
 });

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

@@ -73,3 +73,148 @@ describe("TableQuestionSchema", () => {
         expect(() => tableQuestions_1.TableQuestionSchema.parse(invalidTableQuestion)).toThrow();
     });
 });
+describe("ResearchOutputTableQuestionSchema", () => {
+    it("should validate a valid ResearchOutputTableQuestion object", () => {
+        const validResearchOutputTableQuestion = {
+            type: "researchOutputTable",
+            columns: [
+                {
+                    heading: "Title",
+                    required: true,
+                    enabled: true,
+                    content: {
+                        type: "text",
+                        meta: {
+                            schemaVersion: "1.0"
+                        }
+                    }
+                },
+                {
+                    heading: "Output Type",
+                    required: true,
+                    enabled: true,
+                    content: {
+                        type: "selectBox",
+                        attributes: {
+                            multiple: false
+                        },
+                        options: [
+                            { label: "Foo", value: "foo" },
+                            { label: "Bar", value: "bar" }
+                        ],
+                        meta: {
+                            schemaVersion: "1.0"
+                        }
+                    }
+                },
+                {
+                    heading: "Byte Size",
+                    required: false,
+                    enabled: true,
+                    content: {
+                        type: "numberWithContext",
+                        attributes: {
+                            min: 0,
+                            step: 1,
+                            context: [
+                                { label: 'bytes', value: 'bytes' },
+                                { label: 'KB (kilobytes)', value: 'kb' },
+                                { label: 'MB (megabytes)', value: 'mb' },
+                                { label: 'GB (gigabytes)', value: 'gb' },
+                                { label: 'TB (terabytes)', value: 'tb' },
+                                { label: 'PB (petabytes)', value: 'pb' }
+                            ]
+                        },
+                        meta: {
+                            schemaVersion: "1.0"
+                        }
+                    }
+                },
+                {
+                    heading: "Repositories",
+                    required: false,
+                    enabled: true,
+                    preferences: [
+                        { label: "Repository 1", value: "https://repo.example.com/1" },
+                        { label: "Repository 2", value: "https://repo.example.com/2" }
+                    ],
+                    content: {
+                        type: "repositorySearch",
+                        attributes: {
+                            label: "Repository Search",
+                            help: "Search for a repository",
+                        },
+                        graphQL: {
+                            query: "query Repositories($term: String, $keywords: [String!], $repositoryType: String, $paginationOptions: PaginationOptions){ repositories(term: $term, keywords: $keywords, repositoryType: $repositoryType, paginationOptions: $paginationOptions) { totalCount currentOffset limit hasNextPage hasPreviousPage availableSortFields items { id name uri description website keywords repositoryTypes } } }",
+                            displayFields: [
+                                {
+                                    propertyName: "name",
+                                    label: "Name"
+                                },
+                                {
+                                    propertyName: "description",
+                                    label: "Description"
+                                },
+                                {
+                                    propertyName: "website",
+                                    label: "Website"
+                                },
+                                {
+                                    propertyName: "keywords",
+                                    label: "Subject Areas"
+                                }
+                            ],
+                            answerField: "uri",
+                            responseField: "repositories.items",
+                            variables: [
+                                {
+                                    type: "string",
+                                    name: "term",
+                                    label: "Search term",
+                                    minLength: 2
+                                },
+                                {
+                                    type: "string",
+                                    name: "repositoryType",
+                                    label: "Repository Type"
+                                },
+                                {
+                                    type: "string",
+                                    name: "keywords",
+                                    label: "Subject Areas"
+                                }
+                            ],
+                        },
+                        meta: {
+                            schemaVersion: "1.0"
+                        }
+                    }
+                }
+            ],
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => tableQuestions_1.ResearchOutputTableQuestionSchema.parse(validResearchOutputTableQuestion)).not.toThrow();
+    });
+    it("should throw an error for an invalid ResearchOutputTableQuestion object", () => {
+        const invalidResearchOutputTableQuestion = {
+            type: "researchOutputTable",
+            columns: [
+                {
+                    heading: "Title",
+                    content: {
+                        type: "invalid",
+                        meta: {
+                            schemaVersion: "1.0"
+                        }
+                    }
+                }
+            ],
+            meta: {
+                schemaVersion: "1.0"
+            }
+        };
+        expect(() => tableQuestions_1.ResearchOutputTableQuestionSchema.parse(invalidResearchOutputTableQuestion)).toThrow();
+    });
+});