@dmptool/types 1.2.6 → 2.1.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,23 @@
+"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 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
+const RDA_COMMON_STANDARD_JSON_FILE = './schemas/dmp.schema.json';
+// 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__/dateQuestions.spec.js

@@ -47,6 +47,9 @@ describe("DateRangeQuestion", () => {
     it("should validate a valid DateRangeQuestion object", () => {
         const validDateRange = {
             type: "dateRange",
+            attributes: {
+                label: "Date Range",
+            },
             columns: {
                 start: {
                     label: "Start Date",

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

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