@dmptool/utils 1.0.0

package/dist/maDMP.js

@@ -0,0 +1,982 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDMPToolExtensions = exports.validateRDACommonStandard = void 0;
+exports.planToDMPCommonStandard = planToDMPCommonStandard;
+const jsonschema_1 = require("jsonschema");
+const rds_1 = require("./rds");
+const general_1 = require("./general");
+const types_1 = require("@dmptool/types");
+const maDMPTypes_1 = require("./maDMPTypes");
+const ROR_REGEX = /^https?:\/\/ror\.org\/[0-9a-zA-Z]+$/;
+const DOI_REGEX = /^(https?:\/\/)?(doi\.org\/)?(doi:)?(10\.\d{4,9}\/[-._;()/:\w]+)$/;
+const ORCID_BASE_URL = process.env.ENV && ['stg', 'prd'].includes(process.env.ENV)
+    ? 'https://orcid.org/'
+    : 'https://sandbox.orcid.org/';
+const ORCID_REGEX = /^(https?:\/\/)?(www\.|pub\.)?(sandbox\.)?(orcid\.org\/)?([0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X])$/;
+class DMPValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DMPValidationError';
+    }
+}
+/**
+ * Ensure that the ORCID is in the correct format (https://orcid.org/0000-0000-0000-0000)
+ *
+ * @param orcidIn the ORCID to check
+ * @returns the ORCID in the correct format or null if it is not in the correct format
+ */
+function formatORCID(orcidIn) {
+    // If it is blank or already in the correct format, return it
+    if (orcidIn && (orcidIn.match(ORCID_REGEX) && orcidIn.startsWith('http'))) {
+        return (0, general_1.normaliseHttpProtocol)(orcidIn);
+    }
+    // If it matches the ORCID format but didn't start with http then its just the id
+    if (orcidIn && orcidIn.match(ORCID_REGEX)) {
+        return (0, general_1.normaliseHttpProtocol)(`${ORCID_BASE_URL}${orcidIn.split('/').pop()}`);
+    }
+    // Otherwise it's not an ORCID
+    return null;
+}
+/**
+ * Determine the identifier type for the given URI string
+ *
+ * @param uri the URI string to check
+ * @returns the RDA Common Standard identifier type for the given URI string
+ */
+function determineIdentifierType(uri) {
+    if ((0, general_1.isNullOrUndefined)(uri)) {
+        return 'other';
+    }
+    if (uri.match(ORCID_REGEX)) {
+        return 'orcid';
+    }
+    else if (uri.match(DOI_REGEX)) {
+        return 'doi';
+    }
+    else if (uri.match(ROR_REGEX)) {
+        return 'ror';
+    }
+    else if (uri.startsWith('http')) {
+        return 'url';
+    }
+    else {
+        return 'other';
+    }
+}
+/**
+ * Function to convert a PlanFunding status to an RDA Common Standard funding_status
+ *
+ * @param status the PlanFunding status to convert
+ * @returns the RDA Common Standard funding_status
+ */
+// Helper function to convert a ProjectFundingStatus to a DMPFundingStatus
+function planFundingStatusToDMPFundingStatus(status) {
+    switch (status) {
+        case 'DENIED':
+            return 'rejected';
+        case 'GRANTED':
+            return 'granted';
+        default:
+            return 'planned';
+    }
+}
+/**
+ * Function to convert a 5 character language code (e.g. en-US) to a 3 character code (e.g. eng)
+ *
+ * @param language the 5 character language code to convert
+ * @returns the 3 character language code
+ */
+function convertFiveCharToThreeChar(language) {
+    switch (language) {
+        case 'pt-BR':
+            return 'por';
+        default:
+            return 'eng';
+    }
+}
+/**
+ * Function to generate the base of an internal ID namespace
+ *
+ * @param projectId the Project ID to use for the internal ID namespace
+ * @param planId the Plan ID to use for the internal ID namespace
+ * @returns the base of the internal ID namespace
+ */
+function internalIdBase(projectId, planId) {
+    return `${process.env.APPLICATION_NAME}.projects.${projectId}.dmp.${planId}`;
+}
+/**
+ * Fetch the default MemberRole from the MySQL database
+ *
+ * @returns the default MemberRole as a string (or undefined if there is no default)
+ */
+const loadDefaultMemberRole = async () => {
+    const sql = 'SELECT * FROM memberRoles WHERE isDefault = 1';
+    const resp = await (0, rds_1.queryTable)(sql, []);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        return resp.results[0].id;
+    }
+    return undefined;
+};
+/**
+ * Fetches the Plan information needed to construct the DMP Common Standard from
+ * the MySQL database
+ *
+ * @param planId the Plan ID to fetch the Plan information for
+ * @returns the Plan information needed to construct the DMP Common Standard
+ */
+// Fetch the Plan info needed from the MySQL database
+const loadPlanInfo = async (planId) => {
+    const sql = `
+    SELECT id, dmpId, projectId, versionedTemplateId,
+           createdById, created, modifiedById, modified, title,
+           status, visibility, featured, registeredBy, registered,
+           languageId
+    FROM plans
+    WHERE id = ?
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [planId.toString()]);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        return resp.results[0];
+    }
+    return undefined;
+};
+/**
+ * Fetches the Project information needed to construct the DMP Common Standard
+ * from the MySQL database
+ *
+ * @param projectId the Project ID to fetch the Project information for
+ * @returns the Project information needed to construct the DMP Common Standard
+ */
+const loadProjectInfo = async (projectId) => {
+    const sql = `
+    SELECT id, title, abstractText, startDate, endDate
+    FROM projects
+    WHERE id = ?
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [projectId.toString()]);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        return resp.results[0];
+    }
+    return undefined;
+};
+/**
+ * Fetches the PlanFunding information needed to construct the DMP Common Standard
+ * from the MySQL database
+ *
+ * @param planId the Plan ID to fetch the PlanFunding information for
+ * @returns the Funding information needed to construct the DMP Common Standard
+ */
+const loadFundingInfo = async (planId) => {
+    const sql = `
+    SELECT pf.id, a.uri, a.name, prf.status, prf.grantId,
+           prf.funderProjectNumber, prf.funderOpportunityNumber
+    FROM planFundings pf
+      LEFT JOIN projectFundings prf ON pf.projectFundingId = prf.id
+      LEFT JOIN affiliations a ON prf.affiliationId = a.uri
+    WHERE pf.planId = ?
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [planId.toString()]);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        const fundings = resp.results.filter((row) => !(0, general_1.isNullOrUndefined)(row));
+        fundings.forEach((funding) => funding.status = planFundingStatusToDMPFundingStatus(funding.status));
+        return resp.results;
+    }
+    return [];
+};
+/**
+ * Fetches the Plan's owner information needed to construct the DMP Common Standard
+ * from the MySQL database
+ *
+ * @param ownerId the user id for the plan's owner
+ * @returns the contact information needed to construct the DMP Common Standard
+ */
+async function loadContactFromPlanOwner(ownerId) {
+    const sql = `
+    SELECT u.id, u.givenName, u.surName, u.orcid, a.uri, a.name,
+           (SELECT ue.email
+            FROM userEmails ue
+            WHERE ue.userId = u.id AND ue.isPrimary = 1 LIMIT 1) as email
+    FROM users u
+      LEFT JOIN affiliations a ON u.affiliationId = a.id
+    WHERE u.id = ?
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [ownerId.toString()]);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        return resp.results.filter((row) => !(0, general_1.isNullOrUndefined)(row))[0];
+    }
+    return undefined;
+}
+/**
+ * Fetches the PlanMember information needed to construct the DMP Common Standard
+ * from the MySQL database
+ *
+ * @param planId the Plan ID to fetch the PlanMember information for
+ * @returns the contributor information needed to construct the DMP Common Standard
+ */
+const loadMemberInfo = async (planId) => {
+    const sql = `
+    SELECT pc.id, a.uri, a.name, pctr.email, pctr.givenName, pctr.surName,
+           pctr.orcid, pc.isPrimaryContact, GROUP_CONCAT(r.uri) as roles
+    FROM planMembers pc
+      LEFT JOIN planMemberRoles pcr ON pc.id = pcr.planMemberId
+        LEFT JOIN memberRoles r ON pcr.memberRoleId = r.id
+      LEFT JOIN projectMembers pctr ON pc.projectMemberId = pctr.id
+        LEFT JOIN affiliations a ON pctr.affiliationId = a.uri
+    WHERE pc.planId = ?
+    GROUP BY a.uri, a.name, pctr.email, pctr.givenName, pctr.surName,
+      pctr.orcid, pc.isPrimaryContact;
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [planId.toString()]);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        return resp.results.filter((row) => !(0, general_1.isNullOrUndefined)(row));
+    }
+    return [];
+};
+/**
+ * Returns a default RDA Common Standard Dataset entry for the DMP.
+ * This is used when the Plan has no Answers to a Research Outputs question.
+ *
+ * @param projectId the Project ID to use for the Dataset entry
+ * @param planId the Plan ID to use for the Dataset entry
+ * @returns a generic default Dataset entry
+ */
+const defaultDataset = (projectId, planId) => {
+    return {
+        dataset_id: {
+            identifier: `${internalIdBase(projectId, planId)}.outputs.1`,
+            type: 'other'
+        },
+        personal_data: 'unknown',
+        sensitive_data: 'unknown',
+        title: 'Generic Dataset',
+        type: 'dataset'
+    };
+};
+/**
+ * Fetches the Dataset information needed to construct the DMP Common Standard
+ * from the MySQL database this information is extracted from the Answers table
+ * for Research Output Questions
+ *
+ * @param projectId the Project ID to fetch the Dataset information for
+ * @param planId the Plan ID to fetch the Dataset information for
+ * @param language the language to use for the Dataset information
+ * @returns the dataset information needed to construct the DMP Common Standard
+ */
+const loadDatasetInfo = async (projectId, planId, language = 'eng') => {
+    const datasets = [];
+    const sql = `
+    SELECT a.json
+    FROM answers a
+    WHERE a.planId = ?
+      AND a.json LIKE '%"researchOutputsTable"%';
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [planId.toString()]);
+    // There would typically only be one research outputs question per plan but
+    // we need to allow for multiples just in case.
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        for (const result of resp.results) {
+            // Extract the column headings and the rows
+            const json = result.json ? JSON.parse(result.json) : {};
+            const lang = language === 'eng' ? 'eng' : convertFiveCharToThreeChar(language);
+            // Loop through the rows and construct the RDA Common Standard Dataset object
+            for (let idx = 0; idx < json.answer.length; idx++) {
+                const row = json.answer[idx];
+                datasets.push(buildDataset(idx, row, projectId, planId, lang));
+            }
+        }
+    }
+    else {
+        return [defaultDataset(projectId, planId)];
+    }
+    return datasets;
+};
+/**
+ * Builds the RDA Common Standard Related Identifier entries for the DMP
+ *
+ * @param projectId the Project ID to fetch the Related Works information for
+ * @returns the RDA Common Standard Related Identifier entries for the DMP
+ */
+const loadRelatedWorksInfo = async (projectId) => {
+    const sql = `
+    SELECT w.doi AS identifier, LOWER(wv.workType) AS workType,
+    FROM relatedWorks rw
+      JOIN workVersions wv ON rw.workVersionId = wv.id
+        JOIN works w ON wv.workId = w.id
+    WHERE rw.projectId = ?;
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [projectId.toString()]);
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        const works = resp.results.filter((row) => !(0, general_1.isNullOrUndefined)(row));
+        // Determine the identifier types
+        return works.map((work) => {
+            var _a;
+            return {
+                relation_type: 'cites',
+                identifier: work.identifier,
+                type: determineIdentifierType(work.identifier),
+                resource_type: (_a = work.workType) === null || _a === void 0 ? void 0 : _a.toLowerCase(),
+            };
+        });
+    }
+    return [];
+};
+/**
+ * Builds the DMP Tool Narrative extension for the DMP
+ *
+ * @param planId the Plan ID to fetch the narrative information for
+ * @returns the DMP Tool Narrative extension for the DMP
+ */
+const loadNarrativeTemplateInfo = async (planId) => {
+    // Fetch the template, sections, questions and answers all at once
+    const sql = `
+    SELECT t.id templateId, t.name templateTitle, t.description templateDescription,
+           t.version templateVersion,
+           s.id sectionId, s.name sectionTitle, s.introduction sectionDescription,
+           s.displayOrder sectionOrder, q.id questionId, q.questionText questionText,
+           q.displayOrder questionOrder, a.id answerId, a.json answerJSON
+    FROM plans p
+      INNER JOIN versionedTemplates t ON p.versionedTemplateId = t.id
+        LEFT JOIN versionedSections s ON s.versionedTemplateId = t.id
+          LEFT JOIN versionedQuestions q ON q.versionedSectionId = s.id
+            LEFT JOIN answers a ON a.versionedQuestionId = q.id AND p.id = a.planId
+    WHERE p.id = ?
+    ORDER BY s.displayOrder, q.displayOrder;
+  `;
+    const resp = await (0, rds_1.queryTable)(sql, [planId.toString()]);
+    let results = [];
+    // Filter out any null or undefined results
+    if (resp && Array.isArray(resp.results) && resp.results.length > 0) {
+        results = resp.results.filter((row) => !(0, general_1.isNullOrUndefined)(row));
+    }
+    if (!Array.isArray(results) || results.length === 0) {
+        return undefined;
+    }
+    // Sort the questions by display order
+    results[0].section.forEach((section) => {
+        section.question.sort((a, b) => a.questionOrder - b.questionOrder);
+    });
+    // Sort the sections by display order
+    results[0].section.sort((a, b) => {
+        return a.sectionOrder - b.sectionOrder;
+    });
+    return {
+        id: results[0].templateId,
+        title: results[0].templateTitle,
+        description: results[0].templateDescription,
+        version: results[0].templateVersion,
+        section: results[0].section.map((section) => {
+            return {
+                id: section.sectionId,
+                title: section.sectionTitle,
+                description: section.sectionDescription,
+                order: section.sectionOrder,
+                question: section.question.map((question) => {
+                    return {
+                        id: question.questionId,
+                        order: question.questionOrder,
+                        text: question.questionText,
+                        answer: {
+                            id: question.answerId,
+                            json: question.answerJSON
+                        }
+                    };
+                })
+            };
+        })
+    };
+};
+/**
+ * Builds the RDA Common Standard Contact entry for the DMP
+ *
+ * @param plan the Plan information retrieve from the MySQL database
+ * @param members the PlanMembers information retrieve from the MySQL database
+ * @returns the RDA Common Standard Contact entry for the DMP
+ * @throws DMPValidationError if no primary contact is found for the DMP
+ */
+const buildContact = async (plan, members) => {
+    // Extract the primary contact from the members
+    const memberContact = members.find((c) => {
+        return c === null || c === void 0 ? void 0 : c.isPrimaryContact;
+    });
+    // If no primary contact is available, use the plan owner
+    const primary = memberContact && memberContact.email
+        ? memberContact
+        : await loadContactFromPlanOwner(Number(plan.createdById));
+    if (primary && primary.email) {
+        const orcid = primary.orcid ? formatORCID(primary.orcid) : null;
+        // Build the contact entry for the DMP
+        const contactEntry = {
+            contact_id: [{
+                    identifier: orcid !== null ? orcid : primary.email,
+                    type: orcid !== null ? determineIdentifierType(orcid) : 'other',
+                }],
+            mbox: primary.email,
+            name: [primary.givenName, primary.surName].filter((n) => n).join(' ').trim(),
+        };
+        // Add the affiliation to the Contact if it exists
+        if (primary.name) {
+            const contactAffiliation = {
+                name: primary.name
+            };
+            // Add the URI if it exists
+            if (primary.uri) {
+                contactAffiliation.affiliation_id = {
+                    identifier: primary.uri,
+                    type: determineIdentifierType(primary.uri),
+                };
+            }
+            contactEntry.affiliation = [contactAffiliation];
+        }
+        return contactEntry;
+    }
+    else {
+        throw new DMPValidationError('Unable to find a primary contact for the DMP');
+    }
+};
+/**
+ * Builds the RDA Common Standard Contributor array for the DMP from the PlanMembers
+ *
+ * @param planId the Plan ID
+ * @param projectId the Project ID
+ * @param members the PlanMembers information retrieve from the MySQL database
+ * @param defaultRole the default role to use if the member doesn't have a role'
+ * @returns the RDA Common Standard Contributor array for the DMP
+ */
+const buildContributors = (planId, projectId, members, defaultRole) => {
+    if (!Array.isArray(members) || members.length <= 0) {
+        return [];
+    }
+    return members.map((member) => {
+        // Make sure that we always have roles as an array
+        const roles = member.roles && member.roles.includes('[')
+            ? JSON.parse(member.roles)
+            : [defaultRole];
+        // Combine the member's given name and surname into a single name'
+        const contrib = {
+            name: [member.givenName, member.surName]
+                .filter((n) => n).join(' ').trim(),
+            role: roles,
+        };
+        // Use the member's ORCID if it exists, otherwise generate a new one'
+        const formatted = member.orcid ? formatORCID(member.orcid) : null;
+        if (formatted !== null) {
+            contrib.contributor_id = [{
+                    identifier: formatted,
+                    type: determineIdentifierType(formatted)
+                }];
+        }
+        else {
+            // RDA Common Standard requires an id so generate one
+            contrib.contributor_id = [{
+                    identifier: `${internalIdBase(projectId, planId)}.members.${member.id}`,
+                    type: 'other'
+                }];
+        }
+        // Add the affiliation to the Contributor if it exists
+        if (member.name && member.uri) {
+            contrib.affiliation = [{
+                    name: member.name,
+                    affiliation_id: {
+                        identifier: member.uri,
+                        type: determineIdentifierType(member.uri),
+                    }
+                }];
+        }
+        return contrib;
+    });
+};
+/**
+ * Builds the DMP Tool extensions to the RDA Common Standard
+ *
+ * @param plan the Plan information retrieve from the MySQL database
+ * @param project the Project information retrieve from the MySQL database
+ * @param funding the Funding information retrieve from the MySQL database
+ * @returns the DMP metadata with extensions from the DMP Tool
+ */
+const buildDMPToolExtensions = async (plan, project, funding) => {
+    var _a, _b, _c, _d, _e, _f;
+    const extensions = {
+        rda_schema_version: types_1.RDA_COMMON_STANDARD_VERSION,
+        // Ignoring the `!` assertion here because we know we check the env variable
+        // when the entrypoint function is called.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        provenance: process.env.APPLICATION_NAME,
+        featured: plan.featured ? 'yes' : 'no',
+        privacy: (_b = (_a = plan.visibility) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'private',
+        status: (_d = (_c = plan.status) === null || _c === void 0 ? void 0 : _c.toLowerCase()) !== null && _d !== void 0 ? _d : 'draft',
+    };
+    // Generate the DMP Narrative
+    const narrative = await loadNarrativeTemplateInfo(plan.id);
+    // Fetch the research domain if one was specified
+    const research_domain = project.dmptool_research_domain
+        ? { name: project.dmptool_research_domain }
+        : undefined;
+    let funderProject = undefined;
+    let funderOpportunity = undefined;
+    if (funding) {
+        const projectId = {
+            identifier: internalIdBase(project.id, plan.id),
+            type: maDMPTypes_1.StandardIdentifierType.OTHER
+        };
+        const funderId = funding.uri === undefined
+            ? {
+                identifier: `${internalIdBase(project.id, plan.id)}.fundings.${funding.id}`,
+                type: maDMPTypes_1.StandardIdentifierType.OTHER
+            }
+            : {
+                identifier: funding.uri,
+                type: funding.uri.match(ROR_REGEX)
+                    ? maDMPTypes_1.StandardIdentifierType.ROR
+                    : maDMPTypes_1.StandardIdentifierType.URL
+            };
+        // Define the Funder's project number if applicable. project_id and funder_id
+        // are used to help tie the project_identifier to the correct
+        // project[?].funding[?] in the RDA Common Standard.
+        if (funding.funderProjectNumber !== undefined) {
+            funderProject = {
+                project_id: projectId,
+                funder_id: funderId,
+                project_identifier: {
+                    identifier: funding.funderProjectNumber,
+                    type: ((_e = funding.funderProjectNumber) === null || _e === void 0 ? void 0 : _e.startsWith('http'))
+                        ? maDMPTypes_1.StandardIdentifierType.URL
+                        : maDMPTypes_1.StandardIdentifierType.OTHER
+                }
+            };
+        }
+        // Define the Funder's opportunity number if applicable. project_id and
+        // funder_id are used to help tie the opportunity_identifier to the correct
+        // project[?].funding[?] in the RDA Common Standard.
+        if (funding.funderOpportunityNumber !== undefined) {
+            funderOpportunity = {
+                project_id: projectId,
+                funder_id: funderId,
+                opportunity_identifier: {
+                    identifier: funding.funderOpportunityNumber,
+                    type: ((_f = funding.funderOpportunityNumber) === null || _f === void 0 ? void 0 : _f.startsWith('http'))
+                        ? maDMPTypes_1.StandardIdentifierType.URL
+                        : maDMPTypes_1.StandardIdentifierType.OTHER
+                }
+            };
+        }
+    }
+    // Only add these properties if they have values we don't want 'undefined' or
+    // 'null' in the JSON
+    const regDate = (0, general_1.convertMySQLDateTimeToRFC3339)(plan.registered);
+    if (!(0, general_1.isNullOrUndefined)(plan.registered) && regDate !== null) {
+        extensions.registered = regDate;
+    }
+    if (!(0, general_1.isNullOrUndefined)(project.dmptool_research_domain) && research_domain !== undefined) {
+        extensions.research_domain = research_domain;
+    }
+    if (funderProject !== undefined) {
+        extensions.funding_project = [funderProject];
+    }
+    if (funderOpportunity !== undefined) {
+        extensions.funding_opportunity = [funderOpportunity];
+    }
+    if (!(0, general_1.isNullOrUndefined)(narrative)) {
+        extensions.narrative = {
+            download_url: `https://${process.env.DOMAIN_NAME}/dmps/${plan.dmpId}/narrative`,
+            template: narrative
+        };
+    }
+    return extensions;
+};
+/**
+ * Builds the Project and Funding info for the RDA Common Standard
+ *
+ * @param planId the Plan ID
+ * @param project the Project information retrieve from the MySQL database
+ * @param funding the Funding information retrieve from the MySQL database
+ * @returns the Project and Funding info for the RDA Common Standard
+ */
+const buildProject = (planId, project, funding) => {
+    var _a, _b, _c, _d, _e;
+    if ((0, general_1.isNullOrUndefined)(project)) {
+        return undefined;
+    }
+    let fundingObject = undefined;
+    if (funding && funding.name && funding.status) {
+        const grantIdObject = funding.grantId
+            ? {
+                identifier: funding.grantId,
+                type: ((_a = funding.grantId) === null || _a === void 0 ? void 0 : _a.startsWith('http')) ? 'url' : 'other'
+            }
+            : undefined;
+        // RDA Common Standard requires the funder id to be present
+        const funderIdObject = funding.uri
+            ? {
+                identifier: funding.uri,
+                type: ((_b = (funding).uri) === null || _b === void 0 ? void 0 : _b.match(ROR_REGEX)) ? 'ror' : 'url'
+            }
+            : {
+                identifier: `${internalIdBase(project.id, planId)}.fundings.${funding.id}`,
+                type: 'other'
+            };
+        // The RDA Common Standard requires the funder name and status to be present
+        fundingObject = !(0, general_1.isNullOrUndefined)(funding)
+            ? [{
+                    name: (funding).name,
+                    funding_status: planFundingStatusToDMPFundingStatus((funding).status),
+                    grant_id: grantIdObject,
+                    funder_id: funderIdObject
+                }]
+            : undefined;
+        if (grantIdObject !== undefined && fundingObject !== undefined) {
+            fundingObject[0].grant_id = grantIdObject;
+        }
+    }
+    return {
+        title: project.title,
+        description: (_c = project.abstractText) !== null && _c !== void 0 ? _c : undefined,
+        start: (_d = project.startDate) !== null && _d !== void 0 ? _d : undefined,
+        end: (_e = project.endDate) !== null && _e !== void 0 ? _e : undefined,
+        project_id: [{
+                identifier: internalIdBase(project.id, planId),
+                type: 'other'
+            }],
+        funding: fundingObject
+    };
+};
+/**
+ * Extracts the specified column from the columns of a ResearchOutputTable answer row.
+ * @param id the ID of the column to extract
+ * @param columns the columns of the answer row
+ * @returns the specified column if it exists, otherwise undefined
+ */
+const findColumnById = (id, columns) => {
+    return columns.find((col) => {
+        return (col === null || col === void 0 ? void 0 : col.commonStandardId) === id;
+    });
+};
+/**
+ * Converts the size + context into a byte size.
+ *
+ * @param size the NumberWithContextAnswerType
+ * (e.g. `{ answer: { context: 'GB', value: 5 } }`) to convert
+ * @returns the byte size if it could be converted, otherwise undefined
+ */
+const byteSizeToBytes = (size) => {
+    var _a;
+    if ((0, general_1.isNullOrUndefined)(size) || (0, general_1.isNullOrUndefined)(size.answer.value)) {
+        return undefined;
+    }
+    const multipliers = {
+        'TB': 1e12,
+        'GB': 1e9,
+        'MB': 1e6,
+        'KB': 1e3,
+    };
+    const context = size.answer.context.toUpperCase();
+    // If the context has a match in our multipliers, use it, otherwise use 1 as a fallback
+    const multiplier = (_a = multipliers[context]) !== null && _a !== void 0 ? _a : 1;
+    return size.answer.value * multiplier;
+};
+/**
+ * Convert a @dmptool/types researchOutputTable answer row into an RDA Common
+ * Standard Dataset object.
+ *
+ * @param rowIdx the index of the answer row
+ * @param row the answer row
+ * @param projectId the ID of the project that the dataset belongs to
+ * @param planId the ID of the plan that the dataset belongs to
+ * @param language the language of the dataset (defaults to 'eng')
+ * @returns a RDA Common Standard Dataset object
+ */
+const buildDataset = (rowIdx, row, projectId, planId, language = 'eng') => {
+    const title = findColumnById('title', row.columns);
+    const desc = findColumnById('description', row.columns);
+    const typ = findColumnById('type', row.columns);
+    const flags = findColumnById('data_flags', row.columns);
+    const access_date = findColumnById('issued', row.columns);
+    const access = findColumnById('data_access', row.columns);
+    const byte_size = findColumnById('byte_size', row.columns);
+    const host = findColumnById('host', row.columns);
+    const meta = findColumnById('metadata', row.columns);
+    const license = findColumnById('license_ref', row.columns);
+    // The large RDA Common Standard Research Output representation.
+    // Any properties that are commented out are ones that we do not currently support.
+    // Build the Metadata object from the Metadata Standards defined on the Research Output
+    const metadata = (0, general_1.isNullOrUndefined)(meta)
+        ? undefined
+        : meta.answer.map((m) => {
+            return {
+                description: m.metadataStandardName,
+                // RDA Common Standard requires the language, but we can't get it from
+                // the metadata standard repository we use, so just default it
+                language: 'eng',
+                metadata_standard_id: [{
+                        identifier: m.metadataStandardId,
+                        type: determineIdentifierType(m.metadataStandardId)
+                    }]
+            };
+        });
+    // Get the Anticipated Release Date for the dataset
+    const issued = (0, general_1.isNullOrUndefined)(access_date) ? undefined : access_date.answer;
+    // Build the License object from the Licenses defined on the Research Output
+    const licenses = (0, general_1.isNullOrUndefined)(license)
+        ? undefined
+        : license.answer.map((l) => {
+            return {
+                license_ref: l.licenseId,
+                start_date: issued
+            };
+        });
+    // Build the Distribution object from the Repositories defined on the Research Output
+    const distribution = (0, general_1.isNullOrUndefined)(host)
+        ? undefined
+        : host.answer.map((h) => {
+            return {
+                title: (0, general_1.isNullOrUndefined)(title) ? `Dataset ${rowIdx + 1}` : title.answer,
+                // 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: (0, general_1.isNullOrUndefined)(byte_size) ? undefined : byteSizeToBytes(byte_size),
+                // format: ['application/zip'],
+                data_access: (0, general_1.isNullOrUndefined)(access) ? 'restricted' : access.answer,
+                issued,
+                license: licenses,
+                host: {
+                    title: h.repositoryName,
+                    // description: 'This is a test host',
+                    url: h.repositoryId,
+                    host_id: [{
+                            identifier: h.repositoryId,
+                            type: determineIdentifierType(h.repositoryId)
+                        }],
+                    // 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'
+                }
+            };
+        });
+    return {
+        title: (0, general_1.isNullOrUndefined)(title) ? `Dataset ${rowIdx + 1}` : title.answer,
+        type: (0, general_1.isNullOrUndefined)(typ) ? 'dataset' : typ.answer,
+        description: (0, general_1.isNullOrUndefined)(desc) ? undefined : desc.answer,
+        dataset_id: {
+            identifier: `${internalIdBase(projectId, planId)}.outputs.${rowIdx + 1}`,
+            type: 'other'
+        },
+        personal_data: (0, general_1.isNullOrUndefined)(flags) ?
+            'unknown'
+            : (flags.answer.includes('personal') ? 'yes' : 'no'),
+        sensitive_data: (0, general_1.isNullOrUndefined)(flags)
+            ? 'unknown'
+            : (flags.answer.includes('sensitive') ? 'yes' : 'no'),
+        issued,
+        language,
+        metadata,
+        distribution,
+        // data_quality_assurance: [''],
+        // is_reused: false,
+        // keyword: ['test', 'dataset'],
+        // 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'
+        //  }],
+        // }],
+    };
+};
+/**
+ * Validate the specified DMP metadata record against the RDA Common Standard
+ * and DMP Tool extensions schema
+ *
+ * @param dmp The DMP metadata record to validate
+ * @returns the DMP metadata record if it is valid
+ * @throws DMPValidationError if the record is invalid with the error message(s)
+ */
+const validateRDACommonStandard = (dmp) => {
+    const validationErrors = [];
+    const validator = new jsonschema_1.Validator();
+    // Validate against the RDA Common Standard schema
+    const rdaResult = validator.validate(dmp, types_1.RDACommonStandardDMPJSONSchema);
+    if (rdaResult && rdaResult.errors.length > 0) {
+        validationErrors.push(...rdaResult.errors.map(e => `${e.path.join('.')} - ${e.message}`));
+    }
+    if (validationErrors.length > 0) {
+        throw new DMPValidationError(`Invalid RDA Common Standard: ${validationErrors.join('; ')}`);
+    }
+    return dmp;
+};
+exports.validateRDACommonStandard = validateRDACommonStandard;
+/**
+ * Validate the specified DMP metadata record against the RDA Common Standard
+ * and DMP Tool extensions schema
+ *
+ * @param dmp The DMP metadata record to validate
+ * @returns the DMP metadata record if it is valid
+ * @throws DMPValidationError if the record is invalid with the error message(s)
+ */
+const validateDMPToolExtensions = (dmp) => {
+    var _a;
+    const validationErrors = [];
+    // Next validate against the DMP Tool extension schema
+    const extResult = types_1.DMPToolExtensionSchema.safeParse(dmp);
+    if (extResult && !extResult.success && ((_a = extResult.error.issues) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        validationErrors.push(...extResult.error.issues.map(e => `${e.path.join('.')} - ${e.message}`));
+    }
+    if (validationErrors.length > 0) {
+        throw new DMPValidationError(`Invalid DMP Tool extensions: ${validationErrors.join('; ')}`);
+    }
+    return dmp;
+};
+exports.validateDMPToolExtensions = validateDMPToolExtensions;
+/**
+ * Clean the RDA Common Standard portion of the DMP metadata record
+ *
+ * @param plan The plan information
+ * @param dmp
+ * @returns The cleaned DMP metadata record
+ */
+const cleanRDACommonStandard = (plan, dmp) => {
+    // Make sure some of the required properties have a default value
+    if (!dmp.dmp.created)
+        dmp.dmp.created = plan.created;
+    if (!dmp.dmp.modified)
+        dmp.dmp.modified = plan.modified;
+    if (!dmp.dmp.language)
+        dmp.dmp.language = 'eng';
+    if (!dmp.dmp.ethical_issues_exist)
+        dmp.dmp.ethical_issues_exist = 'unknown';
+    return dmp;
+};
+/**
+ *
+ * Generate a JSON representation for a DMP that confirms to the RDA Common Metadata
+ * standard and includes DMP Tool specific extensions to that standard.
+ *
+ * Some things of note about the JSON representation:
+ *   - There are no primitive booleans, booleans are represented as: 'yes',
+ *   'no', 'unknown'
+ *   - There are no primitive dates, strings formatted as 'YYYY-MM-DD hh:mm:ss:msZ'
+ *   are used
+ *   - The `provenance` is used to store the ID of the system that created the DMP
+ *   - The `privacy` should be used to determine authorization for viewing the
+ *   DMP narrative
+ *   - The `featured` indicates whether the DMP is featured on the DMP Tool
+ *   website's public plans page
+ *   - The `registered` indicates whether the DMP is published/registered with DataCite/EZID
+ *   - The `tombstoned` indicates that it was published/registered but is now removed
+ *
+ * @param planId the ID of the plan to generate the DMP for
+ * @returns a JSON representation of the DMP
+ */
+async function planToDMPCommonStandard(planId) {
+    if ((0, general_1.isNullOrUndefined)(process.env.ENV)) {
+        throw new Error('ENV environment variable is not set');
+    }
+    if ((0, general_1.isNullOrUndefined)(process.env.DOMAIN_NAME)) {
+        throw new Error('DOMAIN_NAME environment variable is not set');
+    }
+    if ((0, general_1.isNullOrUndefined)(process.env.APPLICATION_NAME)) {
+        throw new Error('APPLICATION_NAME environment variable is not set');
+    }
+    // Fetch the Plan data
+    const plan = await loadPlanInfo(planId);
+    if (plan === undefined) {
+        throw new DMPValidationError(`Plan not found: ${planId}`);
+    }
+    if ((0, general_1.isNullOrUndefined)(plan.title)) {
+        throw new DMPValidationError(`Plan title not found for plan: ${planId}`);
+    }
+    if ((0, general_1.isNullOrUndefined)(plan.dmpId)) {
+        throw new DMPValidationError(`DMP ID not found for plan: ${planId}`);
+    }
+    // Get the Project data
+    const project = await loadProjectInfo(plan.projectId);
+    if (project === undefined || !project.title) {
+        throw new DMPValidationError(`Project not found: ${plan.projectId}`);
+    }
+    // Get all the plan members and determine the primary contact
+    const members = plan.id ? await loadMemberInfo(plan.id) : [];
+    const contact = await buildContact(plan, members);
+    if (!contact) {
+        throw new DMPValidationError(`Could not establish a primary contact for plan: ${planId}`);
+    }
+    // Get all the funding and narrative info
+    const datasets = await loadDatasetInfo(project.id, plan.id, plan.languageId);
+    // We only allow one funding per plan at this time
+    const fundings = await loadFundingInfo(plan.id);
+    const funding = fundings.length > 0 ? fundings[0] : undefined;
+    const works = await loadRelatedWorksInfo(plan.projectId);
+    const defaultRole = await loadDefaultMemberRole();
+    // If the plan is registered, use the DOI as the identifier, otherwise convert to a URL
+    const dmpId = plan.registered
+        ? {
+            identifier: plan.dmpId,
+            type: 'doi'
+        }
+        : {
+            identifier: `https://${process.env.DOMAIN_NAME}/projects/${project.id}/dmp/${plan.id}`,
+            type: 'url'
+        };
+    // Examine the datasets to determine the status of ethical issues
+    // If the datasets array only contains the default/generic dataset (meaning there
+    // were no research outputs defined) then the status is `unknown`
+    const isDefaultDataset = datasets.length === 1 && datasets[0].title === 'Generic Dataset';
+    const yesFlag = datasets.find((d) => {
+        return d.sensitive_data === 'yes' || d.personal_data === 'yes';
+    });
+    const noFlag = datasets.find((d) => {
+        return d.sensitive_data === 'no' || d.personal_data === 'no';
+    });
+    const unknownEthicalState = isDefaultDataset
+        || ((0, general_1.isNullOrUndefined)(yesFlag) && (0, general_1.isNullOrUndefined)(noFlag));
+    // If we just
+    const hasEthicalIssues = unknownEthicalState
+        ? 'unknown'
+        : ((0, general_1.isNullOrUndefined)(yesFlag) ? 'no' : 'yes');
+    // Generate the RDA Common Standard DMP metadata record
+    const dmp = {
+        dmp: {
+            title: plan.title,
+            ethical_issues_exist: hasEthicalIssues,
+            language: convertFiveCharToThreeChar(plan.languageId),
+            created: (0, general_1.convertMySQLDateTimeToRFC3339)(plan.created),
+            modified: (0, general_1.convertMySQLDateTimeToRFC3339)(plan.modified),
+            dmp_id: dmpId,
+            contact: contact,
+            dataset: datasets,
+        },
+    };
+    const dmpProject = buildProject(plan.id, project, funding);
+    const dmpContributor = buildContributors(plan.id, project.id, members, defaultRole !== null && defaultRole !== void 0 ? defaultRole : 'other');
+    // Add the contributor, project and related identifier properties if they have values
+    if (!(0, general_1.isNullOrUndefined)(dmpProject)) {
+        dmp.dmp.project = [(0, general_1.removeNullAndUndefinedFromObject)(dmpProject)];
+    }
+    if (!(0, general_1.isNullOrUndefined)(dmpContributor)
+        && Array.isArray(dmpContributor)
+        && dmpContributor.length > 0) {
+        dmp.dmp.contributor = (0, general_1.removeNullAndUndefinedFromObject)(dmpContributor);
+    }
+    if (!(0, general_1.isNullOrUndefined)(works) && Array.isArray(works) && works.length > 0) {
+        dmp.dmp.related_identifier = (0, general_1.removeNullAndUndefinedFromObject)(works);
+    }
+    const cleaned = cleanRDACommonStandard(plan, dmp);
+    // Generate the DMP Tool extensions to the RDA Common Standard
+    const extensions = await buildDMPToolExtensions(plan, project, funding);
+    // Return the combined DMP metadata record
+    return {
+        dmp: Object.assign(Object.assign({}, (0, exports.validateRDACommonStandard)(cleaned).dmp), (0, exports.validateDMPToolExtensions)(extensions))
+    };
+}