@dmptool/types 1.1.2 → 1.2.0

package/README.md

@@ -4,62 +4,61 @@ This package provides Types, Zod schemas and JSON schemas to aide in integration
 
 [Zod](https://www.npmjs.com/package/zod) schemas and Typescript Types can be found in the `src/` directory and JSON schemas can be found in the `schemas/` directory.
 
-## Available Schemas/Types
-
 The current version of the schemas can always be found in `CURRENT_SCHEMA_VERSION`. You will need to include the version is any object you create using the types in this file.
 
 Naming conventions:
 - Zod schemas do not include the word `Type` (e.g. `BooleanQuestion`, `CheckboxesAnswer`)
 - Types include the word `Type` (e.g. `BooleanQuestionType`, `CheckboxesAnswerType`)
 
-### DMP Template Support
+## DMP Template Support
 
-The `QuestionTypesEnum` contains a list of all the possible question types currently supported by the DMP Tool. These values correspond with the `type` property of a question type. For example, the `BooleanQuestion` has `type: 'boolean'` and the `SelectBoxQuestion` has `type: 'checkboxes'`.
+The `QuestionFormatsEnum` contains a list of all the possible question types currently supported by the DMP Tool. These values correspond with the `type` property of a question type. For example, the `BooleanQuestion` has `type: 'boolean'` and the `SelectBoxQuestion` has `type: 'selectBoxes'`.
 
 The available question schemas/types are:
 - `AnyQuestion` A Union of all the question types
 - `AnyTableColumnQuestion` A subset of `AnyQuestion`. All of the question types that can be part of a table
+- `AffiliationSearch` A typeahead style field that allows the user to search for affiliations.
 - `BooleanQuestion` A Yes/No True/False question.
 - `CheckboxesQuestion` A question type that supports an array of `option` objects. The user may "check" multiple options.
 - `CurrencyQuestion` A number field that supports the defintiion of a `denomination`. 
 - `DateQuestion` A date field. Supports `YYYY-MM-DD` format.
 - `DateRangeQuestion` A series of 2 date fields. Meant to capture "From" and "To" or "Start" and "End" dates.
 - `EmailQuestion` An email address. Supports multiple emails that are comma separated.
-- `FilteredSearchQuestion` A complex field that allows the user to enter a search term and filters. The field fires a graphQL query and allows the user to potentially select multiple results.
+- `MultiselectBoxQuestion` A select box that allows for multiple selections
 - `NumberQuestion` A numeric field. Supports both integers and floats.
 - `NumberRangeQuestion` A series of 2 number fields. Meant to capture "From" and "To" or "Min" and "Max" numbers.
 - `RadioButtonsQuestion` A question type that supports an array of `option` objects. The user may "select" a single option.
 - `SelectBoxQuestion` A drop down select box that supports an array of `option` objects. A `multiple` flag can be set to allow multi-select.
 - `TableQuestion` A table question type. Each column in the table can be any one of the `AnyTableColumnQuestion` types.
-- `TextAreaQuestion` A text area field. If the `isRichText` flag is set, the user should see a WYSIWYG editor.
 - `TextQuestion` A simple text field
-- `TypeaheadSearchQuestion` A complex question type that allows the user to type into a text field and fires off a graphQL query. The user can select a single result.
+- `TextAreaQuestion` A text area field. If the `isRichText` flag is set, the user should see a WYSIWYG editor.
 - `URLQuestion` A simple URL field.
 
-### DMP Support
+## DMP Support
 
 Each of the question types above has a corresponding answer. The `type` in each answer type must match the `type` of the related question. For example `BooleanAnswer` has `type: 'boolean'` and and the `SelectBoxAnswer` has `type: 'checkboxes'`.
 
 The available answer schemas/types are:
 - `AnyAnswer` A Union of all the answer types
 - `AnyTableColumnAnswer` A subset of `AnyAnswer`. All of the answer types that can be part of a table
+- `AffiliationSearch` The URI of the selected affiliation.
 - `BooleanAnswer` A Yes/No True/False answer.
 - `CheckboxesAnswer` A answer type that supports an array of `option` objects. The user may "check" multiple options.
 - `CurrencyAnswer` A number field that supports the defintiion of a `denomination`. 
 - `DateAnswer` A date field. Supports `YYYY-MM-DD` format.
 - `DateRangeAnswer` A series of 2 date fields. Meant to capture "From" and "To" or "Start" and "End" dates.
 - `EmailAnswer` An email address. Supports multiple emails that are comma separated.
-- `FilteredSearchAnswer` A complex field that allows the user to enter a search term and filters. The field fires a graphQL query and allows the user to potentially select multiple results.
+- `MultiselectAnswer` An array of `option` objects each containing the value of a selected entry.
 - `NumberAnswer` A numeric field. Supports both integers and floats.
+- `DateRangeAnswer` A series of 2 numbers. Meant to capture "From" and "To" or "Start" and "End".
 - `RadioButtonsAnswer` A answer type that supports an array of `option` objects. The user may "select" a single option.
-- `SelectBoxAnswer` A drop down select box that supports an array of `option` objects. A `multiple` flag can be set to allow multi-select.
+- `SelectBoxAnswer` The value the user selected.
 - `TableAnswer` A table answer type. Each column in the table can be any one of the `AnyTableColumnAnswer` types.
-- `TextAreaAnswer` A text area field. If the `isRichText` flag is set, the user should see a WYSIWYG editor.
 - `TextAnswer` A simple text field
-- `TypeaheadSearchAnswer` A complex answer type that allows the user to type into a text field and fires off a graphQL query. The user can select a single result.
+- `TextAreaAnswer` A text area field. If the `isRichText` flag is set, the user should see a WYSIWYG editor.
 - `URLAnswer` A simple URL field.
 
-#### Coming soon
+### Coming soon
 
 RDA Common Standard for DMPs
 
@@ -69,50 +68,123 @@ DMP Tool specific extensions to the RDA Common Standard for DMPs
 
 Add the DMP Tool types to your `package.json` by running `npm add @dmptool/types`
 
-Once added, you can then import the Types and Zod shemas like this:
-`import { BooleanQuestionSchema, BooleanQuestionType, CURRENT_SCHEMA_VERSION } from '@dmptool/types';`
+Use the provided enum for the list of available question/answer formats.
+```
+import { QuestionFormatsEnum } from "../question";
+
+// Display all of the available Question formats
+console.log(Object.values(QuestionFormatsEnum));
+```
+
+Fetch the usage information for a given question format. This can be used to present your users determine which question format to use:
+```
+import { 
+  QuestionFormatsEnum, 
+  QuestionFormatsUsage, 
+  QuestionFormatsUsageInterface 
+} from "@dmptool/types";
+
+// Infer the Types for all of the question formats
+type QuestionType = z.infer<typeof QuestionFormatsEnum>
+
+// List all of the usage information for each question format
+// e.g. { 
+//        title: 'Text Field', 
+//        usageDecription: 'For questions that require short, simple answers.' 
+//      }
+const name: 'text';
+const usage: QuestionFormatsUsageInterface = QuestionFormatsUsage[name as QuestionType];
+
+console.log(usage);
+```
+
+Validate a question's JSON
+```
+import { QuestionSchemaMap } from "@dmptool/types";
 
-// Use the available Type to help define the JSON object
-const boolQ: BooleanQuestionType = {
-  type: "boolean",
+const json = {
+  type: 'email',
   attributes: {
-    label: "Yes or No",
-    help: "Are you sure?",
-    checked: true
+    maxLength: 2000,
+    multiple: true
   },
   meta: {
-    schemaVersion: CURRENT_SCHEMA_VERSION
+    echemaVersion: '1.0'
+  }
+};
+
+// First verify that the question format (`type`) is a known format.
+if (Object.keys(QuestionSchemaMap).includes(json['type'])) {
+  // Validate the json against the Zod schema and if valid, set the questionType
+  try {
+    const result = QuestionSchemaMap[json['type']]?.safeParse(json);
+    if (result && !result.success) {
+      // If there are validation errors, add them to the errors object
+      console.log(result.error.errors);
+    }
+  } catch (e) {
+    console.log(e.message);
   }
 }
+```
 
-// Use the Zod Schema to validate the JSON 
-const isBoolQ = BooleanQuestionSchema.parse(boolQ);
-console.log('isBoolQ', isBoolQ);
-
-// Force an error to see (see below for what a Zod error message looks like)
-try {
-  BooleanQuestionSchema.parse(123);
-} catch (e) {
-  console.log(e.message);
-}
-
-// Use the Schema Maps to get the correct Schema for the specificed question type
-try {
-  // Validate the questionJSON against the Zod schema
-  QuestionSchemaMap[boolQ.type]?.parse(boolQ);
-} catch (e) {
-  console.log(e.message);
-}
-
-// Use the Any unions to generically define a Question or Answer type
-public questionJSON: AnyQuestionType;
-
-// Use the QuestionTypesEnum to fetch a list of all the valid question types
-console.log(QuestionTypeEnums);
+Fetch the default JSON for a given question format:
+```
+import { 
+  AnyQuestionType,
+  QuestionFormatsEnum, 
+  QuestionSchemaMap,  
+} from "@dmptool/types";
+
+// Infer the Types for all of the question formats
+type QuestionType = z.infer<typeof QuestionFormatsEnum>
+
+// Fetch the Zod schema for the question format and then parse it with
+// only the question format type as an input
+// e.g. {
+//        type: 'text',
+//        attributes: {
+//          maxLength: 255,
+//        },
+//        meta: { 
+//          schemaVersion: CURRENT_SCHEMA_VERSION 
+//        },
+//      }
+const name: 'text';
+const schema: z.ZodTypeAny = QuestionSchemaMap[name as QuestionType];
+const parsedSchema: AnyQuestionType = schema.parse({ type: name });
+
+console.log(parsedSchema);
 ```
 
+Fetch the default JSON for a given answer format:
+```
+import { 
+  AnyAnswerType,
+  AnswerSchemaMap,
+  QuestionFormatsEnum,
+} from "@dmptool/types";
+
+// Infer the Types for all of the question formats
+type AnswerType = z.infer<typeof QuestionFormatsEnum>
+
+// Fetch the Zod schema for the question format and then parse it with
+// only the question format type as an input
+// e.g. {
+//        type: 'text',
+//        answer: '',
+//        meta: { 
+//          schemaVersion: CURRENT_SCHEMA_VERSION 
+//        },
+//      }
+const name: 'text';
+const schema: z.ZodTypeAny = AnswerSchemaMap[name as AnswerType];
+const parsedSchema: AnyAnswerType = schema.parse({ type: name });
+
+console.log(parsedSchema);
+```
 
-Example Zod error:
+Example Zod error thrown while parsing:
 ```
 ZodError: [
   {

package/dist/answers/__tests__/answers.spec.js

@@ -111,10 +111,10 @@ const questions_1 = require("../../questions");
         (0, globals_1.expect)(() => textAnswers_1.TextAreaAnswerSchema.parse(invalidData)).toThrow();
     });
     (0, globals_1.it)('should validate AffiliationSearchAnswer', () => {
-        const validData = { type: 'typeaheadSearch', answer: 'Search term', meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION } };
+        const validData = { type: 'affiliationSearch', answer: 'Search term', meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION } };
         (0, globals_1.expect)(() => graphQLAnswers_1.AffiliationSearchAnswerSchema.parse(validData)).not.toThrow();
-        const invalidData = { type: 'typeaheadSearch', answer: 12345, meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION } };
-        (0, globals_1.expect)(() => questions_1.AffiliationSearchQuestionSchema.parse(invalidData)).toThrow();
+        const invalidData = { type: 'affiliationSearch', answer: 12345, meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION } };
+        (0, globals_1.expect)(() => graphQLAnswers_1.AffiliationSearchAnswerSchema.parse(invalidData)).toThrow();
     });
     (0, globals_1.it)('should validate URLAnswer', () => {
         const validData = { type: 'url', answer: 'https://example.com', meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION } };
@@ -125,44 +125,36 @@ const questions_1 = require("../../questions");
     (0, globals_1.it)('should validate TableAnswer', () => {
         const validData = {
             type: 'table',
+            columnHeadings: [
+                'Name',
+                'Age',
+            ],
             answer: [
                 {
                     columns: [
                         {
-                            heading: "Name",
-                            content: {
-                                type: 'text',
-                                answer: 'Leia Organa',
-                                meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
-                            }
+                            type: 'text',
+                            answer: 'Leia Organa',
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
                         },
                         {
-                            heading: "Age",
-                            content: {
-                                type: 'number',
-                                answer: 28,
-                                meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
-                            }
-                        }
+                            type: 'number',
+                            answer: 28,
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+                        },
                     ]
                 },
                 {
                     columns: [
                         {
-                            heading: "Name",
-                            content: {
-                                type: 'text',
-                                answer: 'Han Solo',
-                                meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
-                            }
+                            type: 'text',
+                            answer: 'Han Solo',
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
                         },
                         {
-                            heading: "Age",
-                            content: {
-                                type: 'number',
-                                answer: 35,
-                                meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
-                            }
+                            type: 'number',
+                            answer: 35,
+                            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
                         }
                     ]
                 }

package/dist/answers/__tests__/usage.spec.d.ts

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

package/dist/answers/__tests__/usage.spec.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const questions_1 = require("../../questions");
+const index_1 = require("../index");
+// Parse the Zod schema with no input to generate the default JSON schemas
+function defaultJSON(name) {
+    if (name in index_1.AnswerSchemaMap) {
+        const schema = index_1.AnswerSchemaMap[name];
+        return schema.parse({ type: name });
+    }
+    else {
+        return null;
+    }
+}
+describe('Get question answer defaultJSON', () => {
+    it('for affiliationSearch question format', () => {
+        const json = defaultJSON('affiliationSearch');
+        const expectedJSON = {
+            type: 'affiliationSearch',
+            answer: '',
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(json).toEqual(expectedJSON);
+    });
+    it('for boolean question format', () => {
+        const json = defaultJSON('boolean');
+        const expectedJSON = {
+            type: 'boolean',
+            answer: false,
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(json).toEqual(expectedJSON);
+    });
+    it('for checkBoxes question format', () => {
+        const json = defaultJSON('checkBoxes');
+        const expectedJSON = {
+            type: 'checkBoxes',
+            answer: [''],
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(json).toEqual(expectedJSON);
+    });
+    it('for currency question format', () => {
+        const json = defaultJSON('currency');
+        const expectedJSON = {
+            type: 'currency',
+            answer: 0,
+            meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+        };
+        expect(json).toEqual(expectedJSON);
+    });
+});
+it('for date question format', () => {
+    const json = defaultJSON('date');
+    const expectedJSON = {
+        type: 'date',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for dateRange question format', () => {
+    const json = defaultJSON('dateRange');
+    const expectedJSON = {
+        type: 'dateRange',
+        answer: {
+            start: '',
+            end: '',
+        },
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for email question format', () => {
+    const json = defaultJSON('email');
+    const expectedJSON = {
+        type: 'email',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for multiselectBox question format', () => {
+    const json = defaultJSON('multiselectBox');
+    const expectedJSON = {
+        type: 'multiselectBox',
+        answer: [''],
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for number question format', () => {
+    const json = defaultJSON('number');
+    const expectedJSON = {
+        type: 'number',
+        answer: 0,
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for numberRange format', () => {
+    const json = defaultJSON('numberRange');
+    const expectedJSON = {
+        type: 'numberRange',
+        answer: {
+            start: 0,
+            end: 0,
+        },
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for radioButtons question format', () => {
+    const json = defaultJSON('radioButtons');
+    const expectedJSON = {
+        type: 'radioButtons',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for selectBox question format', () => {
+    const json = defaultJSON('selectBox');
+    const expectedJSON = {
+        type: 'selectBox',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for table question format', () => {
+    const json = defaultJSON('table');
+    const expectedJSON = {
+        type: 'table',
+        columnHeadings: [
+            'Column A',
+        ],
+        answer: [{
+                columns: [{
+                        type: 'textArea',
+                        answer: '',
+                        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+                    }],
+            }],
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for text question format', () => {
+    const json = defaultJSON('text');
+    const expectedJSON = {
+        type: 'text',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for textArea question format', () => {
+    const json = defaultJSON('textArea');
+    const expectedJSON = {
+        type: 'textArea',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});
+it('for url question format', () => {
+    const json = defaultJSON('url');
+    const expectedJSON = {
+        type: 'url',
+        answer: '',
+        meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION },
+    };
+    expect(json).toEqual(expectedJSON);
+});

package/dist/answers/answer.d.ts

@@ -1,25 +1,22 @@
 import { z } from 'zod';
 export declare const AnswerSchema: z.ZodObject<{
-    type: z.ZodEnum<["affiliationSearch", "boolean", "checkBoxes", "currency", "date", "dateRange", "email", "filteredSearch", "multiselectBox", "number", "numberRange", "radioButtons", "selectBox", "table", "text", "textArea", "url"]>;
-    answer: z.ZodString;
-    meta: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"1.0">;
+    type: z.ZodEnum<["affiliationSearch", "boolean", "checkBoxes", "currency", "date", "dateRange", "email", "multiselectBox", "number", "numberRange", "radioButtons", "selectBox", "table", "text", "textArea", "url"]>;
+    meta: z.ZodDefault<z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: "1.0";
+        schemaVersion: string;
     }, {
-        schemaVersion: "1.0";
-    }>;
+        schemaVersion?: string | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
-    type: "number" | "boolean" | "affiliationSearch" | "checkBoxes" | "currency" | "date" | "dateRange" | "email" | "filteredSearch" | "multiselectBox" | "numberRange" | "radioButtons" | "selectBox" | "table" | "text" | "textArea" | "url";
+    type: "number" | "boolean" | "affiliationSearch" | "checkBoxes" | "currency" | "date" | "dateRange" | "email" | "multiselectBox" | "numberRange" | "radioButtons" | "selectBox" | "table" | "text" | "textArea" | "url";
     meta: {
-        schemaVersion: "1.0";
+        schemaVersion: string;
     };
-    answer: string;
 }, {
-    type: "number" | "boolean" | "affiliationSearch" | "checkBoxes" | "currency" | "date" | "dateRange" | "email" | "filteredSearch" | "multiselectBox" | "numberRange" | "radioButtons" | "selectBox" | "table" | "text" | "textArea" | "url";
-    meta: {
-        schemaVersion: "1.0";
-    };
-    answer: string;
+    type: "number" | "boolean" | "affiliationSearch" | "checkBoxes" | "currency" | "date" | "dateRange" | "email" | "multiselectBox" | "numberRange" | "radioButtons" | "selectBox" | "table" | "text" | "textArea" | "url";
+    meta?: {
+        schemaVersion?: string | undefined;
+    } | undefined;
 }>;
 export type AnswerType = z.infer<typeof AnswerSchema>;

package/dist/answers/answer.js

@@ -5,9 +5,8 @@ const zod_1 = require("zod");
 const question_1 = require("../questions/question");
 // Abstract base schema for all answers
 exports.AnswerSchema = zod_1.z.object({
-    type: question_1.QuestionTypesEnum, // The type of answer
-    answer: zod_1.z.string(), // The answer to the question (string)
+    type: question_1.QuestionFormatsEnum, // The type of answer
     meta: zod_1.z.object({
-        schemaVersion: zod_1.z.literal(question_1.CURRENT_SCHEMA_VERSION), // The schema version of the answer
-    })
+        schemaVersion: zod_1.z.string().default(question_1.CURRENT_SCHEMA_VERSION), // The schema version of the answer
+    }).default({})
 });

package/dist/answers/dateAnswers.d.ts

@@ -1,52 +1,52 @@
 import { z } from 'zod';
 export declare const DateAnswerSchema: z.ZodObject<{
-    answer: z.ZodString;
-    meta: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"1.0">;
+    meta: z.ZodDefault<z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: "1.0";
+        schemaVersion: string;
     }, {
-        schemaVersion: "1.0";
-    }>;
+        schemaVersion?: string | undefined;
+    }>>;
 } & {
     type: z.ZodLiteral<"date">;
+    answer: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     type: "date";
     meta: {
-        schemaVersion: "1.0";
+        schemaVersion: string;
     };
     answer: string;
 }, {
     type: "date";
-    meta: {
-        schemaVersion: "1.0";
-    };
-    answer: string;
+    meta?: {
+        schemaVersion?: string | undefined;
+    } | undefined;
+    answer?: string | undefined;
 }>;
 export declare const DateRangeAnswerSchema: z.ZodObject<{
-    meta: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"1.0">;
+    meta: z.ZodDefault<z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: "1.0";
+        schemaVersion: string;
     }, {
-        schemaVersion: "1.0";
-    }>;
+        schemaVersion?: string | undefined;
+    }>>;
 } & {
     type: z.ZodLiteral<"dateRange">;
-    answer: z.ZodObject<{
-        start: z.ZodString;
-        end: z.ZodString;
+    answer: z.ZodDefault<z.ZodObject<{
+        start: z.ZodDefault<z.ZodString>;
+        end: z.ZodDefault<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         start: string;
         end: string;
     }, {
-        start: string;
-        end: string;
-    }>;
+        start?: string | undefined;
+        end?: string | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     type: "dateRange";
     meta: {
-        schemaVersion: "1.0";
+        schemaVersion: string;
     };
     answer: {
         start: string;
@@ -54,13 +54,13 @@ export declare const DateRangeAnswerSchema: z.ZodObject<{
     };
 }, {
     type: "dateRange";
-    meta: {
-        schemaVersion: "1.0";
-    };
-    answer: {
-        start: string;
-        end: string;
-    };
+    meta?: {
+        schemaVersion?: string | undefined;
+    } | undefined;
+    answer?: {
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
 }>;
 export type DateAnswerType = z.infer<typeof DateAnswerSchema>;
 export type DateRangeAnswerType = z.infer<typeof DateRangeAnswerSchema>;

package/dist/answers/dateAnswers.js

@@ -5,12 +5,13 @@ const zod_1 = require("zod");
 const answer_1 = require("./answer");
 // Answers to Date Question Types
 exports.DateAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('date'), // The type of question
+    type: zod_1.z.literal('date'),
+    answer: zod_1.z.string().default('')
 }));
 exports.DateRangeAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('dateRange'), // The type of answer
+    type: zod_1.z.literal('dateRange'),
     answer: zod_1.z.object({
-        start: zod_1.z.string(), // The start date (string)
-        end: zod_1.z.string() // The end date (string)
-    })
+        start: zod_1.z.string().default(''), // The start date (string)
+        end: zod_1.z.string().default('') // The end date (string)
+    }).default({})
 }));