@dmptool/types 2.0.0 → 2.2.0

package/dist/dmp/extension.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultExtensionSchema = exports.ExtensionSchema = exports.DefaultNarrative = void 0;
+// DMP Tool extensions to the RDA Common Standard
+//    See: https://github.com/RDA-DMP-Common/RDA-DMP-Common-Standard
+//
+const zod_1 = require("zod");
+const answers_1 = require("../answers");
+// the DMP visibility setting (should be used to check authorization)
+const visibilityTypes = [
+    'public',
+    'private',
+    'embargoed',
+];
+// The types of research facilities
+const researchFacilityTypes = [
+    'data_center',
+    'field_station',
+    'laboratory',
+    'observatory',
+    'other',
+];
+// Relation types are derived from the DataCite schema
+const relationTypes = [
+    "is_cited_by",
+    "cites",
+    "is_supplement_to",
+    "is_supplemented_by",
+    "is_continued_by",
+    "continues",
+    "is_described_by",
+    "describes",
+    "has_metadata",
+    "is_metadata_for",
+    "has_version",
+    "is_version_of",
+    "is_new_version_of",
+    "is_previous_version_of",
+    "is_part_of",
+    "has_part",
+    "is_published_in",
+    "is_referenced_by",
+    "references",
+    "is_documented_by",
+    "documents",
+    "is_compiled_by",
+    "compiles",
+    "is_variant_form_of",
+    "is_original_form_of",
+    "is_identical_to",
+    "is_reviewed_by",
+    "reviews",
+    "is_derived_from",
+    "is_source_of",
+    "is_required_by",
+    "requires",
+    "obsoletes",
+    "is_obsoleted_by",
+    "is_collected_by",
+    "collects",
+    "is_translation_of",
+    "has_translation"
+];
+// Work types are derived from the DataCite schema
+const workTypes = [
+    "audiovisual",
+    "book",
+    "book_chapter",
+    "collection",
+    "computational_notebook",
+    "conference_paper",
+    "conference_proceeding",
+    "data_paper",
+    "dataset",
+    "dissertation",
+    "event",
+    "image",
+    "instrument",
+    "interactive_resource",
+    "journal",
+    "journal_article",
+    "model",
+    "output_management_plan",
+    "peer_review",
+    "physical_object",
+    "preprint",
+    "project",
+    "report",
+    "service",
+    "software",
+    "sound",
+    "standard",
+    "study_registration",
+    "text",
+    "workflow",
+    "other"
+];
+const ResearchDomainSchema = zod_1.z.object({
+    // The human-readable name for the research domain
+    name: zod_1.z.string(),
+    // The identifier for the research domain
+    research_domain_identifier: zod_1.z.object({
+        identifier: zod_1.z.string().optional(),
+        type: zod_1.z.enum(['ark', 'doi', 'handle', 'url', 'other']).default('url')
+    }),
+});
+const RelatedIdentifierSchema = zod_1.z.object({
+    // The description of how the DMP is related to the work (e.g. the DMP "cites" the work)
+    descriptor: zod_1.z.enum(relationTypes).default('cites'),
+    // The identifier of the work
+    identifier: zod_1.z.string(),
+    // The type of identifier
+    type: zod_1.z.enum(['ark', 'doi', 'handle', 'url']).default('url'),
+    // The type of the work
+    work_type: zod_1.z.enum(workTypes).default('dataset'),
+});
+const ResearchFacilitySchema = zod_1.z.object({
+    // The human-readable name of the research facility
+    name: zod_1.z.string(),
+    // The facility type
+    type: zod_1.z.enum(researchFacilityTypes).default('other'),
+    // The identifier for the research facility
+    research_facility_identifier: zod_1.z.object({
+        identifier: zod_1.z.string(),
+        type: zod_1.z.enum(['ark', 'doi', 'handle', 'url', 'other']).default('url')
+    }),
+});
+const FundingOpportunitySchema = zod_1.z.object({
+    // The id of the project this opportunity maps to
+    project_id: zod_1.z.object({
+        identifier: zod_1.z.string(),
+        type: zod_1.z.enum(['ark', 'doi', 'handle', 'url', 'other']).default('other')
+    }),
+    // The id of the funding this opportunity maps to within the project
+    funder_id: zod_1.z.object({
+        identifier: zod_1.z.string(),
+        type: zod_1.z.enum(['ror', 'url', 'other']).default('ror')
+    }),
+    // The opportunity id
+    opportunity_identifier: zod_1.z.object({
+        identifier: zod_1.z.string(),
+        type: zod_1.z.enum(['ark', 'doi', 'handle', 'url', 'other']).default('url')
+    })
+});
+const VersionSchema = zod_1.z.object({
+    // URL to fetch the historical version of the DMP
+    access_url: zod_1.z.string(),
+    // The date of the version
+    version_date: zod_1.z.iso.datetime(),
+});
+const NarrativeAnswerSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    json: answers_1.AnyAnswerSchema,
+});
+const DefaultAnswer = NarrativeAnswerSchema.parse({
+    id: 0,
+    json: answers_1.DefaultTextAreaAnswer
+});
+const NarrativeQuestionSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    order: zod_1.z.number(),
+    text: zod_1.z.string(),
+    answer: NarrativeAnswerSchema.optional(),
+});
+const DefaultQuestion = NarrativeQuestionSchema.parse({
+    id: 0,
+    order: 0,
+    text: 'Undefined question text',
+    answer: DefaultAnswer
+});
+const NarrativeSectionSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    order: zod_1.z.number(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    question: zod_1.z.array(NarrativeQuestionSchema)
+});
+const DefaultSection = NarrativeSectionSchema.parse({
+    id: 0,
+    order: 0,
+    title: 'Undefined section',
+    question: [DefaultQuestion]
+});
+const NarrativeTemplateSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    version: zod_1.z.string().optional(),
+    section: zod_1.z.array(NarrativeSectionSchema)
+});
+const DefaultNarrativeTemplate = NarrativeTemplateSchema.parse({
+    id: 0,
+    title: 'Undefined template',
+    section: [DefaultSection]
+});
+// URLs to fetch the narrative as a document other than JSON
+const NarrativeURLsSchema = zod_1.z.object({
+    csv: zod_1.z.string().optional(),
+    docx: zod_1.z.string().optional(),
+    html: zod_1.z.string().optional(),
+    pdf: zod_1.z.string().optional(),
+});
+const NarrativeSchema = zod_1.z.object({
+    download_urls: NarrativeURLsSchema.optional(),
+    template: NarrativeTemplateSchema.optional(),
+});
+exports.DefaultNarrative = NarrativeSchema.parse({
+    template: DefaultNarrativeTemplate
+});
+exports.ExtensionSchema = zod_1.z.object({
+    // The name of the system that owns this record
+    provenance: zod_1.z.string(),
+    // The visibility setting for the DMP
+    privacy: zod_1.z.enum(visibilityTypes).default('private'),
+    // Whether the DMP is featured on the public plans page of the DMP Tool website
+    featured: zod_1.z.enum(['yes', 'no']).default('no'),
+    // The date the DMP Id was registered as a DOI with EZID/DataCite
+    registered: zod_1.z.iso.datetime().optional(),
+    // The narrative content of the DMP expressed as a JSON object
+    narrative: NarrativeSchema.optional(),
+    // The research domain of the project/DMP
+    research_domain: ResearchDomainSchema.optional(),
+    // Other works related to the DMP
+    related_identifier: zod_1.z.array(RelatedIdentifierSchema).optional(),
+    // Research facilities used to collect or process data
+    research_facility: zod_1.z.array(ResearchFacilitySchema).optional(),
+    // Historical versions of the DMP
+    version: zod_1.z.array(VersionSchema).optional(),
+    // Funding opportunity / call for grant submissions related to the funding
+    funding_opportunity: zod_1.z.array(FundingOpportunitySchema).optional(),
+});
+exports.DefaultExtensionSchema = exports.ExtensionSchema.parse({
+    provenance: 'your-application',
+});

package/dist/dmp/index.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { FromSchema } from "json-schema-to-ts";
+import { ExtensionType } from "./extension";
+declare const jsonSchema: any;
+export declare const RDACommonStandardDMPJSONSchema: any;
+export type RDACommonStandardDMPType = FromSchema<typeof jsonSchema>;
+export type DMPToolDMPType = RDACommonStandardDMPType & ExtensionType;
+export declare const ExtensionJSONSchema: z.core.JSONSchema.JSONSchema;
+export {};

package/dist/dmp/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionJSONSchema = exports.RDACommonStandardDMPJSONSchema = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const extension_1 = require("./extension");
+// The RDA Common Standard for DMPs JSON schema is automatically downloaded by
+// scripts/importRDACommonStandard.ts script. This file fetches the specified
+// version of the schema and places it into the schemas/ directory.
+//
+// At this time, there is a PR to add support for converting a JSON Schema into
+// a Zod schema, but it is not there yet.
+//
+// Convert the downloaded JSON schema into types
+// First try resolving via the package export (works when installed from GitHub branch or npm)
+function resolveSchemaPath() {
+    // Try using Node's module resolution against the package export
+    try {
+        // require.resolve respects the "exports" map in package.json
+        const resolved = require.resolve("@dmptool/types/schemas/dmp.schema.json");
+        if (resolved && fs_1.default.existsSync(resolved)) {
+            return resolved;
+        }
+        // If require.resolve found a path but it doesn't exist, log it for debugging
+        console.warn(`[dmptool-types] require.resolve found path but it doesn't exist: ${resolved}`);
+    }
+    catch (_a) {
+        // ignore and fall back to local paths below
+    }
+    // Fallbacks based on local file structure when running from source or built dist
+    // This handles multiple installation scenarios:
+    // 1. npm/published package with dist/schemas
+    // 2. Source code with ts-node/ts-node-dev
+    // 3. GitHub branch installation where dist is gitignored but schemas/ is committed
+    const schemaCandidatePaths = [
+        // When running compiled code from dist: dist/dmp/index.js -> dist/schemas/dmp.schema.json
+        path_1.default.resolve(__dirname, "..", "schemas", "dmp.schema.json"),
+        // When running from source with ts-node: src/dmp/index.ts -> compiled as dist/dmp/index.js -> schemas/dmp.schema.json at repo root
+        path_1.default.resolve(__dirname, "..", "..", "schemas", "dmp.schema.json"),
+        // When installed as node_module from GitHub: node_modules/@dmptool/types/dist/dmp/index.js
+        // Go up to package root, then into schemas: dist/dmp -> dist -> package_root -> schemas
+        path_1.default.resolve(__dirname, "..", "..", "..", "schemas", "dmp.schema.json"),
+    ];
+    // Remove duplicates while preserving order
+    const uniquePaths = Array.from(new Set(schemaCandidatePaths));
+    return uniquePaths.find((candidate) => fs_1.default.existsSync(candidate));
+}
+const RDA_COMMON_STANDARD_JSON_FILE = resolveSchemaPath();
+if (!RDA_COMMON_STANDARD_JSON_FILE) {
+    const attemptedPaths = [
+        path_1.default.resolve(__dirname, "..", "schemas", "dmp.schema.json"),
+        path_1.default.resolve(__dirname, "..", "..", "schemas", "dmp.schema.json"),
+        path_1.default.resolve(__dirname, "..", "..", "..", "schemas", "dmp.schema.json"),
+    ];
+    throw new Error(`Unable to locate dmp.schema.json. Current __dirname: ${__dirname}. Attempted paths: ${attemptedPaths.join(", ")}`);
+}
+// Double-check the file exists before trying to read it
+if (!fs_1.default.existsSync(RDA_COMMON_STANDARD_JSON_FILE)) {
+    throw new Error(`Schema file path was resolved to ${RDA_COMMON_STANDARD_JSON_FILE} but the file does not exist. This may indicate an issue with the package installation or build process.`);
+}
+// Ignoring ESLint here because it doesn't like that we're only using jsonSchema as a Type
+// but that's exactly what we want to do.
+const jsonSchema = JSON.parse(fs_1.default.readFileSync(RDA_COMMON_STANDARD_JSON_FILE, "utf8"));
+exports.RDACommonStandardDMPJSONSchema = jsonSchema;
+exports.ExtensionJSONSchema = zod_1.z.toJSONSchema(extension_1.ExtensionSchema);

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './answers';
+export * from './dmp';
 export * from './questions';

package/dist/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Export All the Zod schemas and types
 __exportStar(require("./answers"), exports);
+__exportStar(require("./dmp"), exports);
 __exportStar(require("./questions"), exports);

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

@@ -158,7 +158,7 @@ describe('questions return the expected defaults', () => {
                         type: "OFFSET",
                         name: "paginationOptions",
                         label: "Pagination Options",
-                        labelTranslationKey: "PaginationOptions.label",
+                        labelTranslationKey: "PaginationOptions.label"
                     }
                 ],
                 responseField: "metadataStandards.items",
@@ -337,7 +337,7 @@ describe('questions return the expected defaults', () => {
                         attributes: {
                             step: 1
                         },
-                        meta: { schemaVersion: "1.0" },
+                        meta: { schemaVersion: "1.0" }
                     }
                 },
                 {

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

@@ -63,7 +63,8 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
             ],
             meta: {
                 schemaVersion: "1.0"
-            }
+            },
+            showCommentField: false
         };
         (0, globals_1.expect)(() => optionBasedQuestions_1.CheckboxesQuestionSchema.parse(validCheckboxesQuestion)).not.toThrow();
     });
@@ -110,7 +111,8 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
             ],
             meta: {
                 schemaVersion: "1.0"
-            }
+            },
+            showCommentField: false
         };
         (0, globals_1.expect)(() => optionBasedQuestions_1.RadioButtonsQuestionSchema.parse(validRadioButtonsQuestion)).not.toThrow();
     });
@@ -154,7 +156,8 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
             ],
             meta: {
                 schemaVersion: "1.0"
-            }
+            },
+            showCommentField: false
         };
         (0, globals_1.expect)(() => optionBasedQuestions_1.SelectBoxQuestionSchema.parse(validSelectBoxQuestion)).not.toThrow();
     });
@@ -202,7 +205,8 @@ const optionBasedQuestions_1 = require("../optionBasedQuestions");
             ],
             meta: {
                 schemaVersion: "1.0"
-            }
+            },
+            showCommentField: false
         };
         (0, globals_1.expect)(() => optionBasedQuestions_1.MultiselectBoxQuestionSchema.parse(validSelectBoxQuestion)).not.toThrow();
     });

package/dist/questions/dateQuestions.d.ts

@@ -9,6 +9,7 @@ export declare const DateQuestionSchema: z.ZodObject<{
         help: z.ZodOptional<z.ZodString>;
         labelTranslationKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    showCommentField: z.ZodOptional<z.ZodBoolean>;
     meta: z.ZodObject<{
         schemaVersion: z.ZodDefault<z.ZodString>;
         title: z.ZodOptional<z.ZodString>;
@@ -30,6 +31,7 @@ export declare const DefaultDateQuestion: {
         title?: string | undefined;
         usageDescription?: string | undefined;
     };
+    showCommentField?: boolean | undefined;
 };
 export declare const DateRangeQuestionSchema: z.ZodObject<{
     type: z.ZodLiteral<"dateRange">;
@@ -51,6 +53,7 @@ export declare const DateRangeQuestionSchema: z.ZodObject<{
             labelTranslationKey: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>;
+    showCommentField: z.ZodOptional<z.ZodBoolean>;
     attributes: z.ZodObject<{
         label: z.ZodOptional<z.ZodString>;
         help: z.ZodOptional<z.ZodString>;
@@ -92,6 +95,7 @@ export declare const DefaultDateRangeQuestion: {
         title?: string | undefined;
         usageDescription?: string | undefined;
     };
+    showCommentField?: boolean | undefined;
 };
 export type DateQuestionType = z.infer<typeof DateQuestionSchema>;
 export type DateRangeQuestionType = z.infer<typeof DateRangeQuestionSchema>;

package/dist/questions/dateQuestions.js

@@ -6,7 +6,7 @@ const question_1 = require("./question");
 const DateAttributesSchema = zod_1.z.object(Object.assign(Object.assign({}, question_1.BaseAttributesSchema.shape), { max: zod_1.z.string().optional(), min: zod_1.z.string().optional(), step: zod_1.z.number().default(1) }));
 const DefaultDateAttributes = DateAttributesSchema.parse({});
 // Date question and answer
-exports.DateQuestionSchema = zod_1.z.object(Object.assign(Object.assign({}, question_1.QuestionSchema.shape), { type: zod_1.z.literal('date'), attributes: DateAttributesSchema }));
+exports.DateQuestionSchema = zod_1.z.object(Object.assign(Object.assign({}, question_1.QuestionSchema.shape), { type: zod_1.z.literal('date'), attributes: DateAttributesSchema, showCommentField: zod_1.z.boolean().optional() }));
 exports.DefaultDateQuestion = exports.DateQuestionSchema.parse({
     type: 'date',
     attributes: DefaultDateAttributes,
@@ -18,7 +18,7 @@ const DateRangeEndColumnSchema = zod_1.z.object(Object.assign(Object.assign({},
 exports.DateRangeQuestionSchema = zod_1.z.object(Object.assign(Object.assign({}, question_1.QuestionSchema.shape), { type: zod_1.z.literal('dateRange'), columns: zod_1.z.object({
         start: DateRangeStartColumnSchema,
         end: DateRangeEndColumnSchema,
-    }) }));
+    }), showCommentField: zod_1.z.boolean().optional() }));
 exports.DefaultDateRangeQuestion = exports.DateRangeQuestionSchema.parse({
     type: 'dateRange',
     attributes: question_1.BaseAttributesSchema.parse({}),