@dmptool/types 1.2.6 → 2.1.0

package/dist/answers/tableAnswers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResearchOutputTableAnswerSchema = exports.TableAnswerSchema = exports.TableRowAnswerSchema = exports.AnyTableColumnAnswerSchema = void 0;
+exports.AnyTableColumnAnswerJSONSchema = exports.ResearchOutputTableAnswerJSONSchema = exports.TableAnswerJSONSchema = exports.DefaultResearchOutputTableAnswer = exports.ResearchOutputTableAnswerSchema = exports.DefaultTableAnswer = exports.TableAnswerSchema = exports.AnyTableColumnAnswerSchema = void 0;
 const zod_1 = require("zod");
 const answer_1 = require("./answer");
 const optionBasedAnswers_1 = require("./optionBasedAnswers");
@@ -30,76 +30,40 @@ exports.AnyTableColumnAnswerSchema = zod_1.z.discriminatedUnion('type', [
     textAnswers_1.TextAreaAnswerSchema,
     textAnswers_1.URLAnswerSchema
 ]);
-exports.TableRowAnswerSchema = zod_1.z.object({
+const TableRowAnswerSchema = zod_1.z.object({
     columns: zod_1.z.array(exports.AnyTableColumnAnswerSchema) // The answers for each column in the row
 });
+const DefaultTableRowAnswer = TableRowAnswerSchema.parse({
+    columns: [textAnswers_1.DefaultTextAreaAnswer]
+});
 // Answers to Table Question Types
-exports.TableAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('table'),
-    columnHeadings: zod_1.z.array(zod_1.z.string()).default(['Column A']),
-    answer: zod_1.z.array(exports.TableRowAnswerSchema).default([{
-            columns: [{
-                    type: 'textArea',
-                    answer: '',
-                    meta: { schemaVersion: questions_1.CURRENT_SCHEMA_VERSION }
-                }]
-        }])
-}));
-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([{
+exports.TableAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('table'), columnHeadings: zod_1.z.array(zod_1.z.string()).default(['Column A']), answer: zod_1.z.array(TableRowAnswerSchema) }));
+exports.DefaultTableAnswer = exports.TableAnswerSchema.parse({
+    type: 'table',
+    columnHeadings: ['Column A'],
+    answer: [DefaultTableRowAnswer],
+    meta: questions_1.DefaultMeta
+});
+exports.ResearchOutputTableAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, exports.TableAnswerSchema.shape), { type: zod_1.z.literal('researchOutputTable'), columnHeadings: zod_1.z.array(zod_1.z.string()).default(['Title', 'Type']) }));
+exports.DefaultResearchOutputTableAnswer = exports.ResearchOutputTableAnswerSchema.parse({
+    type: 'researchOutputTable',
+    columnHeadings: ['Title', 'Type'],
+    answer: [{
             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 }
+                    meta: questions_1.DefaultMeta
                 },
                 {
                     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 }
+                    meta: questions_1.DefaultMeta
                 }
             ]
-        }])
-}));
+        }],
+    meta: questions_1.DefaultMeta
+});
+exports.TableAnswerJSONSchema = zod_1.z.toJSONSchema(exports.TableAnswerSchema);
+exports.ResearchOutputTableAnswerJSONSchema = zod_1.z.toJSONSchema(exports.ResearchOutputTableAnswerSchema);
+exports.AnyTableColumnAnswerJSONSchema = zod_1.z.toJSONSchema(exports.AnyTableColumnAnswerSchema);

package/dist/answers/textAnswers.d.ts

@@ -1,101 +1,65 @@
 import { z } from 'zod';
 export declare const EmailAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"email">;
     answer: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultEmailAnswer: {
     type: "email";
+    answer: string;
     meta: {
         schemaVersion: string;
     };
-    answer: string;
-}, {
-    type: "email";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: string | undefined;
-}>;
+};
 export declare const TextAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"text">;
     answer: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultTextAnswer: {
     type: "text";
+    answer: string;
     meta: {
         schemaVersion: string;
     };
-    answer: string;
-}, {
-    type: "text";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: string | undefined;
-}>;
+};
 export declare const TextAreaAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"textArea">;
     answer: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultTextAreaAnswer: {
     type: "textArea";
+    answer: string;
     meta: {
         schemaVersion: string;
     };
-    answer: string;
-}, {
-    type: "textArea";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: string | undefined;
-}>;
+};
 export declare const URLAnswerSchema: z.ZodObject<{
-    meta: z.ZodDefault<z.ZodObject<{
-        schemaVersion: z.ZodDefault<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
-    }, {
-        schemaVersion?: string | undefined;
-    }>>;
-} & {
     type: z.ZodLiteral<"url">;
     answer: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+    meta: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultURLAnswer: {
     type: "url";
+    answer: string;
     meta: {
         schemaVersion: string;
     };
-    answer: string;
-}, {
-    type: "url";
-    meta?: {
-        schemaVersion?: string | undefined;
-    } | undefined;
-    answer?: string | undefined;
-}>;
+};
 export type EmailAnswerType = z.infer<typeof EmailAnswerSchema>;
 export type TextAnswerType = z.infer<typeof TextAnswerSchema>;
 export type TextAreaAnswerType = z.infer<typeof TextAreaAnswerSchema>;
 export type URLAnswerType = z.infer<typeof URLAnswerSchema>;
+export declare const EmailAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const TextAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const TextAreaAnswerJSONSchema: z.core.JSONSchema.JSONSchema;
+export declare const URLAnswerJSONSchema: z.core.JSONSchema.JSONSchema;

package/dist/answers/textAnswers.js

@@ -1,22 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.URLAnswerSchema = exports.TextAreaAnswerSchema = exports.TextAnswerSchema = exports.EmailAnswerSchema = void 0;
+exports.URLAnswerJSONSchema = exports.TextAreaAnswerJSONSchema = exports.TextAnswerJSONSchema = exports.EmailAnswerJSONSchema = exports.DefaultURLAnswer = exports.URLAnswerSchema = exports.DefaultTextAreaAnswer = exports.TextAreaAnswerSchema = exports.DefaultTextAnswer = exports.TextAnswerSchema = exports.DefaultEmailAnswer = exports.EmailAnswerSchema = void 0;
 const zod_1 = require("zod");
 const answer_1 = require("./answer");
+const questions_1 = require("../questions");
 // Answers to Text Based Question Types
-exports.EmailAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('email'),
-    answer: zod_1.z.string().default('')
-}));
-exports.TextAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('text'),
-    answer: zod_1.z.string().default('')
-}));
-exports.TextAreaAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('textArea'),
-    answer: zod_1.z.string().default('')
-}));
-exports.URLAnswerSchema = answer_1.AnswerSchema.merge(zod_1.z.object({
-    type: zod_1.z.literal('url'),
-    answer: zod_1.z.string().default('')
-}));
+exports.EmailAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('email'), answer: zod_1.z.string().default('') }));
+exports.DefaultEmailAnswer = exports.EmailAnswerSchema.parse({
+    type: 'email',
+    answer: '',
+    meta: questions_1.DefaultMeta
+});
+exports.TextAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('text'), answer: zod_1.z.string().default('') }));
+exports.DefaultTextAnswer = exports.TextAnswerSchema.parse({
+    type: 'text',
+    answer: '',
+    meta: questions_1.DefaultMeta
+});
+exports.TextAreaAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('textArea'), answer: zod_1.z.string().default('') }));
+exports.DefaultTextAreaAnswer = exports.TextAreaAnswerSchema.parse({
+    type: 'textArea',
+    answer: '',
+    meta: questions_1.DefaultMeta
+});
+exports.URLAnswerSchema = zod_1.z.object(Object.assign(Object.assign({}, answer_1.AnswerSchema.shape), { type: zod_1.z.literal('url'), answer: zod_1.z.string().default('') }));
+exports.DefaultURLAnswer = exports.URLAnswerSchema.parse({
+    type: 'url',
+    answer: '',
+    meta: questions_1.DefaultMeta
+});
+exports.EmailAnswerJSONSchema = zod_1.z.toJSONSchema(exports.EmailAnswerSchema);
+exports.TextAnswerJSONSchema = zod_1.z.toJSONSchema(exports.TextAnswerSchema);
+exports.TextAreaAnswerJSONSchema = zod_1.z.toJSONSchema(exports.TextAreaAnswerSchema);
+exports.URLAnswerJSONSchema = zod_1.z.toJSONSchema(exports.URLAnswerSchema);

package/dist/dmp/__tests__/commonStandard.spec.d.ts

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

package/dist/dmp/__tests__/commonStandard.spec.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const jsonschema_1 = require("jsonschema");
+const SCHEMA_PATH = './schemas/dmp.schema.json';
+describe('validate the RDA common standard', () => {
+    it('validates a minimal DMP', async () => {
+        const validator = new jsonschema_1.Validator();
+        const schema = await fs_1.default.readFileSync(SCHEMA_PATH, 'utf8');
+        const dmp = {
+            dmp: {
+                title: 'Test DMP',
+                dmp_id: {
+                    identifier: '123456789',
+                    type: 'other'
+                },
+                created: '2021-01-01 03:11:23Z',
+                modified: '2021-01-01 02:23:11Z',
+                ethical_issues_exist: 'unknown',
+                language: 'eng',
+                contact: {
+                    name: 'Test Contact',
+                    mbox: 'tester@example.com',
+                    contact_id: {
+                        identifier: '123456789',
+                        type: 'other'
+                    }
+                },
+                dataset: [{
+                        title: 'Test Dataset',
+                        dataset_id: {
+                            identifier: '123',
+                            type: 'other'
+                        },
+                        personal_data: 'unknown',
+                        sensitive_data: 'no',
+                    }]
+            }
+        };
+        const result = validator.validate(dmp, JSON.parse(schema));
+        // If there were errors, print them out so we can see why
+        if (result.errors.length > 0)
+            console.log(result.errors);
+        expect(result.errors.length).toBe(0);
+    });
+    it('validates a full DMP', async () => {
+        const validator = new jsonschema_1.Validator();
+        const schema = await fs_1.default.readFileSync(SCHEMA_PATH, 'utf8');
+        const dmp = {
+            dmp: {
+                title: 'Test DMP',
+                description: 'This is a test DMP',
+                dmp_id: {
+                    identifier: '123456789',
+                    type: 'other'
+                },
+                created: '2021-01-01 03:11:23Z',
+                modified: '2021-01-01 02:23:11Z',
+                ethical_issues_exist: 'yes',
+                ethical_issues_description: 'This DMP contains ethical issues',
+                ethical_issues_report: 'https://example.com/ethical-issues-report',
+                language: 'eng',
+                contact: {
+                    name: 'Test Contact',
+                    mbox: 'tester@example.com',
+                    contact_id: {
+                        identifier: 'https://orcid.org/0000-0000-0000-0000',
+                        type: 'orcid'
+                    },
+                    affiliation: [{
+                            name: 'Test University',
+                            affiliation_id: {
+                                identifier: 'https://ror.org/01234567890',
+                                type: 'ror'
+                            }
+                        }],
+                },
+                contributor: [{
+                        name: 'Test Contact',
+                        contributor_id: {
+                            identifier: 'https://orcid.org/0000-0000-0000-0000',
+                            type: 'orcid'
+                        },
+                        affiliation: [{
+                                name: 'Test University',
+                                affiliation_id: {
+                                    identifier: 'https://ror.org/01234567890',
+                                    type: 'ror'
+                                }
+                            }],
+                        role: ['https://example.com/roles/investigation', 'https://example.com/roles/other']
+                    }],
+                cost: [{
+                        title: 'Budget Cost',
+                        description: 'Description of budget costs',
+                        value: 1234.56,
+                        currency_code: 'USD'
+                    }],
+                dataset: [{
+                        title: 'Test Dataset',
+                        type: 'dataset',
+                        description: 'This is a test dataset',
+                        dataset_id: {
+                            identifier: '123',
+                            type: 'other'
+                        },
+                        personal_data: 'unknown',
+                        sensitive_data: 'no',
+                        data_quality_assurance: ['Statement about data quality assurance'],
+                        is_reused: false,
+                        issued: '2026-01-03',
+                        keyword: ['test', 'dataset'],
+                        language: 'eng',
+                        metadata: [{
+                                description: 'Description of metadata',
+                                language: 'eng',
+                                metadata_standard_id: {
+                                    identifier: 'https://example.com/metadata-standards/123',
+                                    type: 'url'
+                                }
+                            }],
+                        preservation_statement: 'Statement about preservation',
+                        security_and_privacy: [{
+                                title: 'Security and Privacy Statement',
+                                description: 'Description of security and privacy statement'
+                            }],
+                        alternate_identifier: [{
+                                identifier: 'https://example.com/dataset/123',
+                                type: 'url'
+                            }],
+                        technical_resource: [{
+                                name: 'Test Server',
+                                description: 'This is a test server',
+                                technical_resource_id: [{
+                                        identifier: 'https://example.com/server/123',
+                                        type: 'url'
+                                    }],
+                            }],
+                        distribution: [{
+                                title: 'Test Distribution',
+                                description: 'This is a test distribution',
+                                access_url: 'https://example.com/dataset/123/distribution/123456789',
+                                download_url: 'https://example.com/dataset/123/distribution/123456789/download',
+                                byte_size: 123456789,
+                                format: ['application/zip'],
+                                data_access: 'open',
+                                issued: '2026-01-03',
+                                license: [{
+                                        license_ref: 'https://spdx.org/licenses/CC-BY-4.0.html',
+                                        start_date: '2026-01-03'
+                                    }],
+                                host: {
+                                    title: 'Test Host',
+                                    description: 'This is a test host',
+                                    url: 'https://example.com/host/123',
+                                    host_id: [{
+                                            identifier: 'https://re3data.org/2784y97245792756789',
+                                            type: 'url'
+                                        }],
+                                    availability: '99.99',
+                                    backup_frequency: 'weekly',
+                                    backup_type: 'tapes',
+                                    certified_with: 'coretrustseal',
+                                    geo_location: 'US',
+                                    pid_system: ['doi', 'ark'],
+                                    storage_type: 'LTO-8 tape',
+                                    support_versioning: 'yes'
+                                }
+                            }]
+                    }],
+                related_identifier: [{
+                        identifier: 'https://doi.org/10.1234/dmp.123456789',
+                        relation_type: 'cites',
+                        resource_type: 'dataset',
+                        type: 'doi'
+                    }],
+                alternate_identifier: [{
+                        identifier: 'https://example.com/dmp/123456789',
+                        type: 'url'
+                    }],
+            },
+            project: [{
+                    title: 'Test Project',
+                    description: 'This is a test project',
+                    project_id: {
+                        identifier: '123456789',
+                        type: 'other'
+                    },
+                    start: '2025-01-01',
+                    end: '2028-01-31',
+                    funding: [{
+                            name: 'Funder Organization',
+                            funding_status: 'planned',
+                            funder_id: {
+                                identifier: 'https://ror.org/0987654321',
+                                type: 'ror'
+                            }
+                        }]
+                }]
+        };
+        const result = validator.validate(dmp, JSON.parse(schema));
+        // If there were errors, print them out so we can see why
+        if (result.errors.length > 0)
+            console.log(result.errors);
+        expect(result.errors.length).toBe(0);
+    });
+});

package/dist/dmp/__tests__/extensions.spec.d.ts

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

package/dist/dmp/__tests__/extensions.spec.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const extension_1 = require("../extension");
+describe('extensions', () => {
+    it('validates a minimal DMP Tool extension', () => {
+        const expected = {
+            provenance: 'your-application',
+            privacy: 'private',
+            featured: 'no',
+        };
+        (0, globals_1.expect)(extension_1.DefaultExtensionSchema).toEqual(expected);
+    });
+    it('validates a full DMP Tool extension', () => {
+        const validData = {
+            provenance: 'your-application',
+            privacy: 'private',
+            featured: 'no',
+            registered: '2026-01-01T10:32:45Z',
+            research_domain: {
+                name: 'biology',
+                research_domain_identifier: {
+                    identifier: 'https://example.com/01234567',
+                    type: 'url'
+                }
+            },
+            related_identifier: [{
+                    identifier: 'https://doi.org/10.1234/dmp.123456789',
+                    descriptor: 'cites',
+                    work_type: 'dataset',
+                    type: 'doi'
+                }],
+            research_facility: [{
+                    name: 'Super telescope',
+                    type: 'observatory',
+                    research_facility_identifier: {
+                        identifier: 'https://example.com/01234567',
+                        type: 'url'
+                    }
+                }],
+            funding_opportunity: [{
+                    project_id: {
+                        identifier: '123456789',
+                        type: 'other'
+                    },
+                    funder_id: {
+                        identifier: 'https://ror.org/0987654321',
+                        type: 'ror'
+                    },
+                    opportunity_identifier: {
+                        identifier: 'https://example.com/01234567',
+                        type: 'url'
+                    }
+                }],
+            version: [{
+                    access_url: 'https://example.com/dmp/123456789?version=2026-01-01T10:32:45Z',
+                    version_date: '2026-01-01T10:32:45Z',
+                }],
+            narrative: {
+                download_urls: {
+                    csv: 'https://example.com/dmp/123456789/narrative.csv',
+                    docx: 'https://example.com/dmp/123456789/narrative.docx',
+                    html: 'https://example.com/dmp/123456789/narrative.html',
+                    pdf: 'https://example.com/dmp/123456789/narrative.pdf',
+                    txt: 'https://example.com/dmp/123456789/narrative.txt',
+                },
+                template: {
+                    id: 1234567,
+                    title: 'Narrative Template',
+                    description: 'This is a test template for a DMP narrative',
+                    version: 'v1',
+                    section: [{
+                            id: 9876,
+                            title: 'Section one',
+                            description: 'The first section of the narrative',
+                            order: 1,
+                            question: [{
+                                    id: 1234,
+                                    text: 'What is the purpose of this DMP?',
+                                    order: 1,
+                                    answer: {
+                                        id: 543,
+                                        json: {
+                                            type: 'repositorySearch',
+                                            answer: [{
+                                                    repositoryId: 'https://example.com/repository/123456789',
+                                                    repositoryName: 'Example Repository',
+                                                }],
+                                            meta: { schemaVersion: '1.0' }
+                                        }
+                                    },
+                                }]
+                        }]
+                }
+            }
+        };
+        (0, globals_1.expect)(() => extension_1.ExtensionSchema.parse(validData)).not.toThrow();
+    });
+});