@dmptool/utils 1.0.0

package/dist/dynamo.js

@@ -0,0 +1,651 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteDMP = exports.tombstoneDMP = exports.updateDMP = exports.createDMP = exports.getDMPs = exports.getDMPVersions = exports.DMPExists = exports.DMP_TOMBSTONE_VERSION = exports.DMP_LATEST_VERSION = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const general_1 = require("./general");
+const DMP_PK_PREFIX = 'DMP';
+// VERSION records store the RDA Common Standard metadata
+const DMP_VERSION_PREFIX = 'VERSION';
+// EXTENSION records store the DMP Tool specific metadata
+const DMP_EXTENSION_PREFIX = 'EXTENSION';
+exports.DMP_LATEST_VERSION = 'latest';
+exports.DMP_TOMBSTONE_VERSION = 'tombstone';
+// The list of properties that are extensions to the RDA Common Standard
+const EXTENSION_KEYS = [
+    'provenance',
+    'privacy',
+    'featured',
+    'registered',
+    'tombstoned',
+    'narrative',
+    'research_domain',
+    'research_facility',
+    'version',
+    'funding_opportunity',
+    'funding_project'
+];
+const dynamoConfigParams = {
+    region: process.env.AWS_REGION || 'us-west-2',
+    maxAttempts: process.env.DYNAMO_MAX_ATTEMPTS
+        ? parseInt(process.env.DYNAMO_MAX_ATTEMPTS)
+        : 3,
+};
+class DMPToolDynamoError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DMPToolDynamoError';
+    }
+}
+// Initialize AWS SDK clients (outside the handler function)
+const dynamoDBClient = new client_dynamodb_1.DynamoDBClient(dynamoConfigParams);
+/**
+ * Lightweight query just to check if the DMP exists.
+ *
+ * @param dmpId
+ * @returns true if the DMP exists, false otherwise.
+ * @throws DMPToolDynamoError if the record could not be fetched due to an error
+ */
+const DMPExists = async (dmpId) => {
+    // Very lightweight here, just returning a PK if successful
+    const params = {
+        KeyConditionExpression: "PK = :pk AND SK = :sk",
+        ExpressionAttributeValues: {
+            ":pk": { S: dmpIdToPK(dmpId) },
+            ":sk": { S: versionToSK(exports.DMP_LATEST_VERSION) }
+        },
+        ProjectExpression: "PK"
+    };
+    try {
+        const response = await queryTable(params);
+        return !(0, general_1.isNullOrUndefined)(response)
+            && Array.isArray(response.Items)
+            && response.Items.length > 0;
+    }
+    catch (err) {
+        throw new DMPToolDynamoError(`Unable to check if DMP exists id: ${dmpId} - ${(0, general_1.toErrorMessage)(err)}`);
+    }
+};
+exports.DMPExists = DMPExists;
+/**
+ * Fetch the version timestamps (including DMP_LATEST_VERSION) for the specified DMP ID.
+ *
+ * @param dmpId
+ * @returns The timestamps as strings (e.g. '2026-11-01T13:08:19Z' or 'latest')
+ * @throws DMPToolDynamoError if the records could not be fetched due to an error
+ */
+const getDMPVersions = async (dmpId) => {
+    const params = {
+        KeyConditionExpression: "PK = :pk AND begins_with(SK, :sk)",
+        ExpressionAttributeValues: {
+            ":pk": { S: dmpIdToPK(dmpId) },
+            ":sk": { S: DMP_VERSION_PREFIX }
+        },
+        ProjectionExpression: "PK, SK, modified"
+    };
+    try {
+        const response = await queryTable(params);
+        if (Array.isArray(response.Items) && response.Items.length > 0) {
+            const versions = [];
+            for (const item of response.Items) {
+                const unmarshalled = (0, util_dynamodb_1.unmarshall)(item);
+                if (unmarshalled.PK && unmarshalled.SK && unmarshalled.modified) {
+                    versions.push({
+                        PK: unmarshalled.PK,
+                        SK: unmarshalled.SK,
+                        modified: unmarshalled.modified
+                    });
+                }
+            }
+            return versions;
+        }
+        return [];
+    }
+    catch (err) {
+        throw new DMPToolDynamoError(`Unable to fetch DMP versions id: ${dmpId} - ${(0, general_1.toErrorMessage)(err)}`);
+    }
+};
+exports.getDMPVersions = getDMPVersions;
+/**
+ * Fetch the RDA Common Standard metadata record with DMP Tool specific extensions
+ * for the specified DMP ID.
+ *
+ * @param dmpId
+ * @param version The version of the DMP metadata record to persist
+ * (e.g. '2026-11-01T13:08:19Z').
+ * If not provided, the latest version will be used. Defaults to DMP_LATEST_VERSION.
+ * @param includeExtensions Whether or not to include the DMP Tool specific
+ * extensions in the returned record. Defaults to true.
+ * @returns The complete RDA Common Standard metadata record with the DMP extension
+ * metadata or an empty array if none were found.
+ * @throws DMPToolDynamoError if the records could not be fetched due to an error
+ */
+// Fetch the specified DMP metadata record
+//   - Version is optional, if it is not provided, ALL versions will be returned
+//   - If you just want the latest version, use the DMP_LATEST_VERSION constant
+const getDMPs = async (dmpId, version, includeExtensions = true) => {
+    let params = {};
+    if (version) {
+        params = {
+            KeyConditionExpression: "PK = :pk and SK = :sk",
+            ExpressionAttributeValues: {
+                ":pk": { S: dmpIdToPK(dmpId) },
+                ":sk": { S: versionToSK(version) }
+            }
+        };
+    }
+    else {
+        params = {
+            KeyConditionExpression: "PK = :pk AND begins_with(SK, :sk)",
+            ExpressionAttributeValues: {
+                ":pk": { S: dmpIdToPK(dmpId) },
+                ":sk": { S: DMP_VERSION_PREFIX }
+            }
+        };
+    }
+    try {
+        const response = await queryTable(params);
+        if (response && response.Items && response.Items.length > 0) {
+            const unmarshalled = response.Items.map(item => (0, util_dynamodb_1.unmarshall)(item));
+            // sort the results by the SK (version) descending
+            const items = unmarshalled.sort((a, b) => {
+                return (b.SK).toString().localeCompare((a.SK).toString());
+            });
+            // If we are including the DMP Tool extensions, then fetch them
+            if (includeExtensions) {
+                // We need to remove properties specific to our DynamoDB table and then
+                // merge in any DMP Tool specific extensions to the RDA Common Standard
+                return await Promise.all(items.map(async (item) => {
+                    // Fetch the DMP Tool extensions
+                    const extensions = await getDMPExtensions(dmpId, item.SK.replace(`${DMP_VERSION_PREFIX}#`, ''));
+                    // Destructure the Dynamo item because we don't need to return the PK and SK
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { PK, SK } = item, version = __rest(item, ["PK", "SK"]);
+                    if (Array.isArray(extensions) && extensions.length > 0) {
+                        return {
+                            dmp: Object.assign(Object.assign({}, version), extensions[0])
+                        };
+                    }
+                    return {
+                        dmp: version,
+                    };
+                }));
+            }
+            else {
+                // Just return the RDA Common Standard metadata record
+                return items.map(item => ({ dmp: (0, util_dynamodb_1.unmarshall)(item) }));
+            }
+        }
+    }
+    catch (err) {
+        throw new DMPToolDynamoError(`Unable to fetch DMP id: ${dmpId}, ver: ${version} - ${(0, general_1.toErrorMessage)(err)}`);
+    }
+    return [];
+};
+exports.getDMPs = getDMPs;
+/**
+ * Fetch the specified DMP Extensions metadata record
+ *
+ * @param dmpId
+ * @param version The version of the DMP metadata record to persist
+ * (e.g. '2026-11-01T13:08:19Z').
+ * If not provided, the latest version will be used. Defaults to DMP_LATEST_VERSION.
+ * @returns The DMP extension metadata records or an empty array if none were found.
+ * @throws DMPToolDynamoError if the record could not be fetched
+ */
+const getDMPExtensions = async (dmpId, version) => {
+    let params = {};
+    if (version) {
+        params = {
+            KeyConditionExpression: "PK = :pk and SK = :sk",
+            ExpressionAttributeValues: {
+                ":pk": { S: dmpIdToPK(dmpId) },
+                ":sk": { S: versionToExtensionSK(version) }
+            }
+        };
+    }
+    else {
+        params = {
+            KeyConditionExpression: "PK = :pk AND begins_with(SK, :sk)",
+            ExpressionAttributeValues: {
+                ":pk": { S: dmpIdToPK(dmpId) },
+                ":sk": { S: DMP_EXTENSION_PREFIX }
+            }
+        };
+    }
+    const response = await queryTable(params);
+    if (response && response.Items && response.Items.length > 0) {
+        const unmarshalled = response.Items.map(item => (0, util_dynamodb_1.unmarshall)(item));
+        // sort the results by the SK (version) descending
+        const items = unmarshalled.sort((a, b) => {
+            return (b.SK).toString().localeCompare((a.SK).toString());
+        });
+        // Coerce the items to the DMP Tool Extension schema
+        return Promise.all(items.map(async (item) => {
+            // Destructure the Dynamo item because we don't need to return the PK and SK
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { PK, SK } = item, extension = __rest(item, ["PK", "SK"]);
+            // Fetch all the version timestamps
+            const versions = await (0, exports.getDMPVersions)(dmpId);
+            if (Array.isArray(versions) && versions.length > 0) {
+                // Return the versions sorted descending
+                extension.version = versions
+                    .sort((a, b) => b.modified.localeCompare(a.modified))
+                    .map((v) => {
+                    // The latest version doesn't have a query param appended to the URL
+                    const queryParam = v.SK.endsWith(exports.DMP_LATEST_VERSION)
+                        ? ''
+                        : `?version=${v.modified}`;
+                    const dmpIdWithoutProtocol = dmpId.replace(/^https?:\/\//, '');
+                    const accessURLBase = `https://${process.env.DOMAIN_NAME}/dmps/`;
+                    return {
+                        access_url: `${accessURLBase}${dmpIdWithoutProtocol}${queryParam}`,
+                        version: v.modified,
+                    };
+                });
+            }
+            return extension;
+        }));
+    }
+    return [];
+};
+/**
+ * Persists the specified DMP metadata record to the DynamoDB table.
+ * This function will handle the separation of RDA Common Standard and DMP Tool
+ * specific metadata.
+ *
+ * @param dmpId The DMP ID (e.g. '123456789')
+ * @param dmp The DMP metadata record to persist as either an RDA Common Standard
+ * or the standard with DMP Tool specific extensions.
+ * @param version The version of the DMP metadata record to persist
+ * (e.g. '2026-11-01T13:08:19Z').
+ * If not provided, the latest version will be used. Defaults to DMP_LATEST_VERSION.
+ * @param includeExtensions Whether or not to include the DMP Tool specific
+ * extensions in the returned record. Defaults to true.
+ * @returns The persisted DMP metadata record as an RDA Common Standard DMP
+ * metadata record with the DMP Tool specific extensions merged in.
+ * @throws DMPToolDynamoError if the record could not be persisted
+ */
+const createDMP = async (dmpId, dmp, version = exports.DMP_LATEST_VERSION, includeExtensions = true) => {
+    var _a;
+    if (!dmpId || dmpId.trim().length === 0 || !dmp) {
+        throw new DMPToolDynamoError('Missing DMP ID or DMP metadata record');
+    }
+    // If the version is LATEST, then first make sure there is not already one present!
+    const exists = await (0, exports.DMPExists)(dmpId);
+    if (exists) {
+        throw new DMPToolDynamoError('Latest version already exists');
+    }
+    try {
+        // If the metadata is nested in a top level 'dmp' property, then unwrap it
+        const innerMetadata = (_a = dmp === null || dmp === void 0 ? void 0 : dmp.dmp) !== null && _a !== void 0 ? _a : dmp;
+        // Separate the RDA Common Standard metadata from the DMP Tool specific extensions
+        const dmptoolExtension = pick(innerMetadata, [...EXTENSION_KEYS]);
+        const rdaCommonStandard = pick(innerMetadata, Object.keys(innerMetadata).filter(k => !EXTENSION_KEYS.includes(k)));
+        const newVersionItem = Object.assign(Object.assign({}, rdaCommonStandard), { PK: dmpIdToPK(dmpId), SK: versionToSK(version) });
+        // Insert the RDA Common Standard metadata record into the DynamoDB table
+        await putItem((0, util_dynamodb_1.marshall)(newVersionItem, { removeUndefinedValues: true }));
+        // Create the DMP Tool extensions metadata record. We ALWAYS do this even if
+        // the caller does not want them returned
+        await createDMPExtensions(dmpId, dmptoolExtension, version);
+        // Fetch the complete DMP metadata record including the RDA Common Standard
+        // and the DMP Tool extensions
+        return (await (0, exports.getDMPs)(dmpId, exports.DMP_LATEST_VERSION, includeExtensions))[0];
+    }
+    catch (err) {
+        // If it was a DMPToolDynamoError that bubbled up, just throw it
+        if (err instanceof DMPToolDynamoError)
+            throw err;
+        throw new DMPToolDynamoError(`Unable to create DMP id: ${dmpId}, ver: ${version} - ${(0, general_1.toErrorMessage)(err)}`);
+    }
+};
+exports.createDMP = createDMP;
+/**
+ * Create a new DMP Extensions metadata record
+ *
+ * @param dmpId
+ * @param dmp
+ * @param version The version of the DMP metadata record to persist
+ * (e.g. '2026-11-01T13:08:19Z').
+ * If not provided, the latest version will be used. Defaults to DMP_LATEST_VERSION.
+ * @returns The persisted DMP Tool extensions metadata record.
+ */
+const createDMPExtensions = async (dmpId, dmp, version = exports.DMP_LATEST_VERSION) => {
+    const newExtensionItem = Object.assign(Object.assign({}, dmp), { PK: dmpIdToPK(dmpId), SK: versionToExtensionSK(version) });
+    // Insert the DMP Tool Extensions metadata record into the DynamoDB table
+    await putItem((0, util_dynamodb_1.marshall)(newExtensionItem, { removeUndefinedValues: true }));
+};
+/**
+ * Update the specified DMP metadata record.
+ * This function will handle the separation of RDA Common Standard and DMP Tool
+ * specific metadata. We always update the latest version of the DMP metadata record.
+ * Historical versions are immutable.
+ *
+ * A snapshot of the current "latest" version of the DMP's metadata will be taken
+ * under the following circumstances:
+ *   - If the `provenance` of the incoming record does not match the one on the
+ *     latest record
+ *   - If the `modified` timestamp of the latest record is older than 2 hours ago
+ *
+ * If a snapshot is made, the timestamp and link to retrieve it will appear
+ * in the `versions` array
+ *
+ * @param dmp
+ * @param includeExtensions Whether or not to include the DMP Tool specific
+ * extensions in the returned record. Defaults to true.
+ * @returns The persisted DMP metadata record as an RDA Common Standard DMP
+ * metadata record with the DMP Tool specific extensions merged in.
+ * @throws DMPToolDynamoError if the record could not be persisted
+ */
+const updateDMP = async (dmp, includeExtensions = true) => {
+    var _a, _b, _c, _d, _e, _f;
+    const dmpId = (_b = (_a = dmp.dmp) === null || _a === void 0 ? void 0 : _a.dmp_id) === null || _b === void 0 ? void 0 : _b.identifier;
+    if (!dmp || !dmpId) {
+        throw new DMPToolDynamoError('Missing DMP ID or DMP metadata record');
+    }
+    try {
+        // If the metadata is nested in a top level 'dmp' property, then unwrap it
+        const innerMetadata = (_c = dmp === null || dmp === void 0 ? void 0 : dmp.dmp) !== null && _c !== void 0 ? _c : dmp;
+        // Separate the RDA Common Standard metadata from the DMP Tool specific extensions
+        const dmptoolExtension = pick(innerMetadata, [...EXTENSION_KEYS]);
+        const rdaCommonStandard = pick(innerMetadata, Object.keys(innerMetadata).filter(k => !EXTENSION_KEYS.includes(k)));
+        // Fetch the current latest version of the plan's maDMP record. Always get
+        // the extensions because we need to check the provenance
+        const latest = (await (0, exports.getDMPs)(dmpId, exports.DMP_LATEST_VERSION, true))[0];
+        // Bail if there is no latest version (it has never been created yet or its tombstoned)
+        // Or if the incoming modified timestamp is newer than the latest version's
+        // modified timestamp (collision)
+        if ((0, general_1.isNullOrUndefined)(latest)
+            || ((_d = latest.dmp) === null || _d === void 0 ? void 0 : _d.tombstoned)
+            || ((_e = latest.dmp) === null || _e === void 0 ? void 0 : _e.modified) > innerMetadata.modified) {
+            throw new DMPToolDynamoError(`Cannot update a historical DMP id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION}`);
+        }
+        const lastModified = new Date((_f = latest.dmp) === null || _f === void 0 ? void 0 : _f.modified).getTime();
+        const now = Date.now();
+        const gracePeriod = process.env.VERSION_GRACE_PERIOD ? Number(process.env.VERSION_GRACE_PERIOD) : 7200000;
+        // We need to version the DMP if the provenance doesn't match or the modified
+        // timestamp is older than 2 hours ago
+        const needToVersion = dmptoolExtension.provenance !== latest.dmp.provenance
+            || (now - lastModified) > gracePeriod;
+        // If it was determined that we need to version the DMP, then create a new snapshot
+        // using the modified date of the current latest version
+        if (needToVersion) {
+            await (0, exports.createDMP)(dmpId, latest.dmp, latest.dmp.modified);
+        }
+        // Updates can only ever occur on the latest version of the DMP (the Plan logic
+        // should handle creating a snapshot of the original version of the DMP when
+        // appropriate)
+        const versionItem = Object.assign(Object.assign({}, rdaCommonStandard), { PK: dmpIdToPK(dmpId), SK: versionToSK(exports.DMP_LATEST_VERSION) });
+        // Insert the RDA Common Standard metadata record into the DynamoDB table
+        await putItem((0, util_dynamodb_1.marshall)(versionItem, { removeUndefinedValues: true }));
+        // Update the DMP Tool extensions metadata record. We ALWAYS do this even if
+        // the caller does not want them returned
+        await updateDMPExtensions(dmpId, dmptoolExtension);
+        // Fetch the complete DMP metadata record including the RDA Common Standard
+        // and the DMP Tool extensions
+        return (await (0, exports.getDMPs)(dmpId, exports.DMP_LATEST_VERSION, includeExtensions))[0];
+    }
+    catch (err) {
+        // If it was a DMPToolDynamoError that bubbled up, just throw it
+        if (err instanceof DMPToolDynamoError)
+            throw err;
+        throw new DMPToolDynamoError(`Unable to create DMP id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION} - ${(0, general_1.toErrorMessage)(err)}`);
+    }
+};
+exports.updateDMP = updateDMP;
+/**
+ * Update the specified DMP Extensions metadata record
+ * We always update the latest version of the DMP metadata record. Historical versions are immutable.
+ *
+ * @param dmpId
+ * @param dmp
+ * @returns The persisted DMP Tool extensions metadata record.
+ */
+const updateDMPExtensions = async (dmpId, dmp) => {
+    // Updates can only ever occur on the latest version of the DMP (the Plan logic
+    // should handle creating a snapshot of the original version of the DMP when appropriate)
+    const extensionItem = Object.assign(Object.assign({}, dmp), { PK: dmpIdToPK(dmpId), SK: versionToExtensionSK(exports.DMP_LATEST_VERSION) });
+    await putItem((0, util_dynamodb_1.marshall)(extensionItem, { removeUndefinedValues: true }));
+};
+/**
+ * Create a Tombstone for the specified DMP metadata record
+ * (registered/published DMPs only!)
+ *
+ * @param dmpId The DMP ID (e.g. '11.12345/A1B2C3')
+ * @param includeExtensions Whether or not to include the DMP Tool specific
+ * extensions in the returned record. Defaults to true.
+ * @returns The new tombstone DMP metadata record as an RDA Common Standard DMP
+ * metadata record with the DMP Tool specific extensions merged in.
+ * @throws DMPToolDynamoError if a tombstone could not be created
+ */
+const tombstoneDMP = async (dmpId, includeExtensions = true) => {
+    var _a, _b;
+    // Get the latest version of the DMP including the extensions because we need
+    // to check the registered status
+    const dmp = (await (0, exports.getDMPs)(dmpId, exports.DMP_LATEST_VERSION, true))[0];
+    if (!dmp) {
+        throw new DMPToolDynamoError(`Unable to find DMP id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION}`);
+    }
+    // If the DMP has been registered (aka published) we can create a tombstone
+    if (dmp.dmp.registered) {
+        // If the metadata is nested in a top level 'dmp' property, then unwrap it
+        const innerMetadata = (_a = dmp === null || dmp === void 0 ? void 0 : dmp.dmp) !== null && _a !== void 0 ? _a : dmp;
+        // Separate the RDA Common Standard metadata from the DMP Tool specific extensions.
+        const dmptoolExtension = pick(innerMetadata, [...EXTENSION_KEYS]);
+        const rdaCommonStandard = pick(innerMetadata, Object.keys(innerMetadata).filter(k => !EXTENSION_KEYS.includes(k)));
+        const now = (0, general_1.convertMySQLDateTimeToRFC3339)(new Date());
+        if ((0, general_1.isNullOrUndefined)(now)) {
+            throw new DMPToolDynamoError('Unable to create modified date');
+        }
+        const versionItem = Object.assign(Object.assign({}, rdaCommonStandard), { PK: dmpIdToPK(dmpId), SK: versionToSK(exports.DMP_TOMBSTONE_VERSION), title: `OBSOLETE: ${(_b = dmp.dmp) === null || _b === void 0 ? void 0 : _b.title}`, modified: now });
+        try {
+            // Update the RDA Common Standard metadata record
+            await putItem((0, util_dynamodb_1.marshall)(versionItem, { removeUndefinedValues: true }));
+            await deleteItem({
+                PK: { S: dmpIdToPK(dmpId) },
+                SK: { S: versionToSK(exports.DMP_LATEST_VERSION) }
+            });
+            // Tombstone the DMP Tool Extensions metadata record. We ALWAYS do this even
+            // if the caller does not want them returned
+            await tombstoneDMPExtensions(dmpId, dmptoolExtension);
+            // Fetch the complete DMP metadata record including the RDA Common Standard
+            // and the DMP Tool extensions
+            return (await (0, exports.getDMPs)(dmpId, exports.DMP_TOMBSTONE_VERSION, includeExtensions))[0];
+        }
+        catch (err) {
+            if (err instanceof DMPToolDynamoError)
+                throw err;
+            throw new DMPToolDynamoError(`Unable to tombstone id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION} - ${(0, general_1.toErrorMessage)(err)}`);
+        }
+    }
+    else {
+        throw new DMPToolDynamoError(`Unable to tombstone DMP id: ${dmpId} because it is not registered/published`);
+    }
+};
+exports.tombstoneDMP = tombstoneDMP;
+/**
+ * Add a tombstone date to the specified DMP Extensions metadata record
+ * (registered/published DMPs only!)
+ *
+ * @param dmpId The DMP ID (e.g. '11.12345/A1B2C3')
+ * @param dmp The DMP Tool specific extensions record to update.
+ * @throws DMPToolDynamoError if the tombstone date could not be added
+ */
+const tombstoneDMPExtensions = async (dmpId, dmp) => {
+    const now = (0, general_1.convertMySQLDateTimeToRFC3339)(new Date());
+    if (!now) {
+        throw new DMPToolDynamoError('Unable to create tombstone date');
+    }
+    const extensionItem = Object.assign(Object.assign({}, dmp), { PK: dmpIdToPK(dmpId), SK: versionToExtensionSK(exports.DMP_TOMBSTONE_VERSION), tombstoned: now });
+    // Update the DMP Tool Extensions metadata record
+    await putItem((0, util_dynamodb_1.marshall)(extensionItem, { removeUndefinedValues: true }));
+    // Then delete the old latest version
+    await deleteItem({
+        PK: { S: dmpIdToPK(dmpId) },
+        SK: { S: versionToExtensionSK(exports.DMP_LATEST_VERSION) }
+    });
+};
+/**
+ * Delete the specified DMP metadata record and any associated DMP Tool extension records.
+ * This will NOT work on DMPs that have been registered/published.
+ *
+ * @param dmpId The DMP ID (e.g. '11.12345/A1B2C3')
+ * @param includeExtensions Whether or not to include the DMP Tool specific extensions
+ * in the returned record. Defaults to true.
+ * @returns The deleted DMP metadata record as an RDA Common Standard DMP metadata
+ * record with the DMP Tool specific extensions merged in.
+ * @throws DMPToolDynamoError if the record could not be deleted
+ */
+const deleteDMP = async (dmpId, includeExtensions = true) => {
+    // Get the latest version of the DMP. Always get the extensions because we need
+    // to check the registered status
+    const dmps = await (0, exports.getDMPs)(dmpId, exports.DMP_LATEST_VERSION, true);
+    if (Array.isArray(dmps) && dmps.length > 0) {
+        const latest = dmps[0];
+        // If the caller wants just the RDA Common Standard metadata, then reload the
+        // latest version without extensions
+        const rdaOnly = pick(latest.dmp, Object.keys(latest.dmp).filter(k => !EXTENSION_KEYS.includes(k)));
+        const toReturn = includeExtensions
+            ? latest
+            : { dmp: rdaOnly };
+        // If the latest version was found, and it has NOT been registered/published
+        if (latest && !latest.dmp.registered) {
+            try {
+                // Delete all records with that DMP ID
+                await deleteItem({ PK: { S: dmpIdToPK(dmpId) } });
+                return toReturn;
+            }
+            catch (err) {
+                throw new DMPToolDynamoError(`Unable to delete id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION} - ${(0, general_1.toErrorMessage)(err)}`);
+            }
+        }
+        else {
+            throw new DMPToolDynamoError(`Unable to delete id: ${dmpId} because it does not exist or is registered`);
+        }
+    }
+    else {
+        throw new DMPToolDynamoError(`Unable to find id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION}`);
+    }
+};
+exports.deleteDMP = deleteDMP;
+/**
+ * Scan the specified DynamoDB table using the specified criteria
+ * @param table
+ * @param params
+ * @returns an array of DynamoDB items
+ */
+// We're not currently using it, but did not want to remove it just in case
+// we need it in the future
+//
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const scanTable = async (table, params) => {
+    let items = [];
+    let lastEvaluatedKey;
+    // Query the DynamoDB index table for all DMP metadata (with pagination)
+    do {
+        const command = new client_dynamodb_1.ScanCommand(Object.assign({ TableName: table, ExclusiveStartKey: lastEvaluatedKey, ConsistentRead: false, ReturnConsumedCapacity: 'TOTAL' }, params));
+        const response = await dynamoDBClient.send(command);
+        // Collect items and update the pagination key
+        items = items.concat(response.Items || []);
+        // LastEvaluatedKey is the position of the end cursor from the query that was just run
+        // when it is undefined, then the query reached the end of the results.
+        lastEvaluatedKey = response === null || response === void 0 ? void 0 : response.LastEvaluatedKey;
+    } while (lastEvaluatedKey);
+    // Deserialize and split items into multiple files if necessary
+    return items;
+};
+/**
+ * Query the specified DynamoDB table using the specified criteria
+ *
+ * @param params
+ * @returns an array of DynamoDB items
+ */
+const queryTable = async (params = {}) => {
+    // Query the DynamoDB index table for all DMP metadata (with pagination)
+    const command = new client_dynamodb_1.QueryCommand(Object.assign({ TableName: process.env.DYNAMODB_TABLE_NAME, ConsistentRead: false, ReturnConsumedCapacity: 'TOTAL' }, params));
+    return await dynamoDBClient.send(command);
+};
+/**
+ * Create/Update an item in the specified DynamoDB table
+ *
+ * @param item
+ */
+const putItem = async (item) => {
+    // Delete the item from the DynamoDB table
+    await dynamoDBClient.send(new client_dynamodb_1.PutItemCommand({
+        TableName: process.env.DYNAMO_TABLE_NAME,
+        ReturnConsumedCapacity: 'TOTAL',
+        Item: item
+    }));
+    return;
+};
+/**
+ * Delete an item from the specified DynamoDB table
+ *
+ * @param key
+ */
+const deleteItem = async (key) => {
+    // Delete the item from the DynamoDB table
+    await dynamoDBClient.send(new client_dynamodb_1.DeleteItemCommand({
+        TableName: process.env.DYNAMO_TABLE_NAME,
+        ReturnConsumedCapacity: 'TOTAL',
+        Key: key
+    }));
+};
+/**
+ * Convert a DMP ID into a PK for the DynamoDB table
+ *
+ * @param dmpId
+ */
+const dmpIdToPK = (dmpId) => {
+    // Remove the protocol and slashes from the DMP ID
+    const id = dmpId === null || dmpId === void 0 ? void 0 : dmpId.replace(/(^\w+:|^)\/\//, '');
+    return `${DMP_PK_PREFIX}#${id}`;
+};
+/**
+ * Convert a DMP ID version timestamp into a SK for the DynamoDB table for the
+ * RDA Common Standard metadata record
+ *
+ * @param version the version as a timestamp or "latest"
+ * (e.g. "2026-11-01T13:08:19Z", "latest")
+ */
+const versionToSK = (version = exports.DMP_LATEST_VERSION) => {
+    return `${DMP_VERSION_PREFIX}#${version}`;
+};
+/**
+ * Convert a DMP ID version timestamp into a SK for the DynamoDB table for a
+ * DMP Tool extension record
+ *
+ * @param version the version as a timestamp or "latest"
+ * (e.g. "2026-11-01T13:08:19Z", "latest")
+ * @returns string
+ */
+const versionToExtensionSK = (version = exports.DMP_LATEST_VERSION) => {
+    return `${DMP_EXTENSION_PREFIX}#${version}`;
+};
+/**
+ * Extract a subset of keys from an object
+ *
+ * @param obj
+ * @param keys
+ */
+function pick(obj, keys) {
+    const result = {};
+    keys.forEach((key) => {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    });
+    return result;
+}

package/dist/eventBridge.d.ts

@@ -0,0 +1,13 @@
+export interface PutEventResponse {
+    status: number;
+    message: string;
+    eventId?: string;
+}
+/**
+ * Publishes an event to EventBridge.
+ *
+ * @param source The name of the caller (e.g. the Lambda Function or Application Function)
+ * @param detailType The type of event (resources typically watch for specific types of events)
+ * @param detail The payload of the event (will be accessible to the invoked resource)
+ */
+export declare const putEvent: (source: string, detailType: string, details: Record<string, unknown>) => Promise<PutEventResponse>;