@dmptool/utils 1.0.4 → 1.0.6

package/dist/dynamo.js

@@ -36,12 +36,6 @@ const EXTENSION_KEYS = [
     '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);
@@ -49,15 +43,22 @@ class DMPToolDynamoError extends Error {
     }
 }
 // Initialize AWS SDK clients (outside the handler function)
-const dynamoDBClient = new client_dynamodb_1.DynamoDBClient(dynamoConfigParams);
+const getDynamoDBClient = (dynamoConfigParams) => {
+    const { region, maxAttempts } = dynamoConfigParams;
+    return new client_dynamodb_1.DynamoDBClient({ region, maxAttempts });
+};
 /**
  * Lightweight query just to check if the DMP exists.
  *
- * @param dmpId
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
  * @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) => {
+const DMPExists = async (dynamoConnectionParams, dmpId) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0) {
+        throw new DMPToolDynamoError('Missing Dynamo config or DMP ID');
+    }
     // Very lightweight here, just returning a PK if successful
     const params = {
         KeyConditionExpression: "PK = :pk AND SK = :sk",
@@ -67,25 +68,32 @@ const DMPExists = async (dmpId) => {
         },
         ProjectExpression: "PK"
     };
+    dynamoConnectionParams.logger.debug(Object.assign(Object.assign({}, params), { dmpId }), 'Checking if DMP exists in DynamoDB');
     try {
-        const response = await queryTable(params);
+        const response = await queryTable(dynamoConnectionParams, 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)}`);
+        const errMsg = (0, general_1.toErrorMessage)(err);
+        dynamoConnectionParams.logger.fatal(Object.assign(Object.assign({}, params), { dmpId, errMsg }), 'Failed to check for DMP existence');
+        throw new DMPToolDynamoError(`Unable to check if DMP exists id: ${dmpId} - ${errMsg}`);
     }
 };
 exports.DMPExists = DMPExists;
 /**
  * Fetch the version timestamps (including DMP_LATEST_VERSION) for the specified DMP ID.
  *
- * @param dmpId
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
  * @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 getDMPVersions = async (dynamoConnectionParams, dmpId) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0) {
+        throw new DMPToolDynamoError('Missing Dynamo Config or DMP ID');
+    }
     const params = {
         KeyConditionExpression: "PK = :pk AND begins_with(SK, :sk)",
         ExpressionAttributeValues: {
@@ -94,8 +102,9 @@ const getDMPVersions = async (dmpId) => {
         },
         ProjectionExpression: "PK, SK, modified"
     };
+    dynamoConnectionParams.logger.debug(Object.assign(Object.assign({}, params), { dmpId }), 'Fetching DMP versions from DynamoDB');
     try {
-        const response = await queryTable(params);
+        const response = await queryTable(dynamoConnectionParams, params);
         if (Array.isArray(response.Items) && response.Items.length > 0) {
             const versions = [];
             for (const item of response.Items) {
@@ -113,7 +122,9 @@ const getDMPVersions = async (dmpId) => {
         return [];
     }
     catch (err) {
-        throw new DMPToolDynamoError(`Unable to fetch DMP versions id: ${dmpId} - ${(0, general_1.toErrorMessage)(err)}`);
+        const errMsg = (0, general_1.toErrorMessage)(err);
+        dynamoConnectionParams.logger.fatal(Object.assign(Object.assign({}, params), { dmpId, errMsg }), 'Failed to fetch DMP versions');
+        throw new DMPToolDynamoError(`Unable to fetch DMP versions id: ${dmpId} - ${errMsg}`);
     }
 };
 exports.getDMPVersions = getDMPVersions;
@@ -121,7 +132,9 @@ exports.getDMPVersions = getDMPVersions;
  * Fetch the RDA Common Standard metadata record with DMP Tool specific extensions
  * for the specified DMP ID.
  *
- * @param dmpId
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param domainName The domain name of the DMPTool instance (e.g. 'dmptool.org')
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
  * @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.
@@ -134,7 +147,10 @@ exports.getDMPVersions = getDMPVersions;
 // 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) => {
+const getDMPs = async (dynamoConnectionParams, domainName, dmpId, version, includeExtensions = true) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0) {
+        throw new DMPToolDynamoError('Missing Dynamo config or DMP ID');
+    }
     let params = {};
     if (version) {
         params = {
@@ -154,8 +170,9 @@ const getDMPs = async (dmpId, version, includeExtensions = true) => {
             }
         };
     }
+    dynamoConnectionParams.logger.debug(Object.assign(Object.assign({}, params), { dmpId, version, includeExtensions }), 'Fetching DMPs from DynamoDB');
     try {
-        const response = await queryTable(params);
+        const response = await queryTable(dynamoConnectionParams, 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
@@ -168,7 +185,7 @@ const getDMPs = async (dmpId, version, includeExtensions = true) => {
                 // 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}#`, ''));
+                    const extensions = await getDMPExtensions(dynamoConnectionParams, domainName, 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"]);
@@ -189,7 +206,9 @@ const getDMPs = async (dmpId, version, includeExtensions = true) => {
         }
     }
     catch (err) {
-        throw new DMPToolDynamoError(`Unable to fetch DMP id: ${dmpId}, ver: ${version} - ${(0, general_1.toErrorMessage)(err)}`);
+        const errMsg = (0, general_1.toErrorMessage)(err);
+        dynamoConnectionParams.logger.fatal(Object.assign(Object.assign({}, params), { dmpId, version, includeExtensions, errMsg }), errMsg);
+        throw new DMPToolDynamoError(`Unable to fetch DMP id: ${dmpId}, ver: ${version} - ${errMsg}`);
     }
     return [];
 };
@@ -197,14 +216,18 @@ exports.getDMPs = getDMPs;
 /**
  * Fetch the specified DMP Extensions metadata record
  *
- * @param dmpId
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
  * @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) => {
+const getDMPExtensions = async (dynamoConnectionParams, domainName, dmpId, version) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0) {
+        throw new DMPToolDynamoError('Missing Dynamo Config or DMP ID');
+    }
     let params = {};
     if (version) {
         params = {
@@ -224,7 +247,8 @@ const getDMPExtensions = async (dmpId, version) => {
             }
         };
     }
-    const response = await queryTable(params);
+    dynamoConnectionParams.logger.debug(Object.assign(Object.assign({}, params), { dmpId, version }), 'Fetching DMP Extensions from DynamoDB');
+    const response = await queryTable(dynamoConnectionParams, 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
@@ -237,7 +261,7 @@ const getDMPExtensions = async (dmpId, version) => {
             // 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);
+            const versions = await (0, exports.getDMPVersions)(dynamoConnectionParams, dmpId);
             if (Array.isArray(versions) && versions.length > 0) {
                 // Return the versions sorted descending
                 extension.version = versions
@@ -248,7 +272,7 @@ const getDMPExtensions = async (dmpId, version) => {
                         ? ''
                         : `?version=${v.modified}`;
                     const dmpIdWithoutProtocol = dmpId.replace(/^https?:\/\//, '');
-                    const accessURLBase = `https://${process.env.DOMAIN_NAME}/dmps/`;
+                    const accessURLBase = `https://${domainName}/dmps/`;
                     return {
                         access_url: `${accessURLBase}${dmpIdWithoutProtocol}${queryParam}`,
                         version: v.modified,
@@ -265,7 +289,9 @@ const getDMPExtensions = async (dmpId, version) => {
  * This function will handle the separation of RDA Common Standard and DMP Tool
  * specific metadata.
  *
- * @param dmpId The DMP ID (e.g. '123456789')
+ * @param dynamoConnectionParams The DynamoDB connection parameters
+ * @param domainName The domain name of the DMPTool instance (e.g. 'dmptool.org')
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
  * @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
@@ -277,14 +303,15 @@ const getDMPExtensions = async (dmpId, version) => {
  * 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) => {
+const createDMP = async (dynamoConnectionParams, domainName, 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 (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0 || !dmp) {
+        throw new DMPToolDynamoError('Missing Dynamo config, 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);
+    const exists = await (0, exports.DMPExists)(dynamoConnectionParams, dmpId);
     if (exists) {
+        dynamoConnectionParams.logger.error({ dmpId }, 'Latest version already exists');
         throw new DMPToolDynamoError('Latest version already exists');
     }
     try {
@@ -294,37 +321,45 @@ const createDMP = async (dmpId, dmp, version = exports.DMP_LATEST_VERSION, inclu
         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) });
+        dynamoConnectionParams.logger.debug({ dmpId, version, includeExtensions }, 'Persisting DMP to DynamoDB');
         // Insert the RDA Common Standard metadata record into the DynamoDB table
-        await putItem((0, util_dynamodb_1.marshall)(newVersionItem, { removeUndefinedValues: true }));
+        await putItem(dynamoConnectionParams, (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);
+        await createDMPExtensions(dynamoConnectionParams, 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];
+        return (await (0, exports.getDMPs)(dynamoConnectionParams, domainName, 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)}`);
+        const errMsg = (0, general_1.toErrorMessage)(err);
+        dynamoConnectionParams.logger.fatal({ dmpId, version, includeExtensions }, errMsg);
+        throw new DMPToolDynamoError(`Unable to create DMP id: ${dmpId}, ver: ${version} - ${errMsg}`);
     }
 };
 exports.createDMP = createDMP;
 /**
  * Create a new DMP Extensions metadata record
  *
- * @param dmpId
- * @param dmp
+ * @param dynamoConnectionParams The DynamoDB connection parameters
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
+ * @param dmp The DMP Tool extensions metadata record
  * @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 createDMPExtensions = async (dynamoConnectionParams, dmpId, dmp, version = exports.DMP_LATEST_VERSION) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0 || !dmp) {
+        throw new DMPToolDynamoError('Missing Dynamo config, DMP ID or DMP metadata record');
+    }
     const newExtensionItem = Object.assign(Object.assign({}, dmp), { PK: dmpIdToPK(dmpId), SK: versionToExtensionSK(version) });
+    dynamoConnectionParams.logger.debug({ dmpId, version }, 'Persisting DMP Extensions to DynamoDB');
     // Insert the DMP Tool Extensions metadata record into the DynamoDB table
-    await putItem((0, util_dynamodb_1.marshall)(newExtensionItem, { removeUndefinedValues: true }));
+    await putItem(dynamoConnectionParams, (0, util_dynamodb_1.marshall)(newExtensionItem, { removeUndefinedValues: true }));
 };
 /**
  * Update the specified DMP metadata record.
@@ -341,18 +376,23 @@ const createDMPExtensions = async (dmpId, dmp, version = exports.DMP_LATEST_VERS
  * If a snapshot is made, the timestamp and link to retrieve it will appear
  * in the `versions` array
  *
- * @param dmp
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param domainName The domain name of the DMPTool instance (e.g. 'dmptool.org')
+ * @param dmp The DMP metadata record to persist as either an RDA Common Standard
+ * or the standard with DMP Tool specific extensions.
+ * @param gracePeriodInMS The grace period in milliseconds to wait before creating
  * @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) => {
+const updateDMP = async (dynamoConnectionParams, domainName, dmp, gracePeriodInMS = 7200000, // 2 hours in milliseconds
+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');
+    if (!dynamoConnectionParams || !dmp || !dmpId) {
+        throw new DMPToolDynamoError('Missing Dynamo config, DMP ID or DMP metadata record');
     }
     try {
         // If the metadata is nested in a top level 'dmp' property, then unwrap it
@@ -362,7 +402,7 @@ const updateDMP = async (dmp, includeExtensions = true) => {
         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];
+        const latest = (await (0, exports.getDMPs)(dynamoConnectionParams, domainName, 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)
@@ -373,36 +413,38 @@ const updateDMP = async (dmp, includeExtensions = true) => {
         }
         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; // 2 hours in milliseconds
+        const gracePeriod = gracePeriodInMS ? Number(gracePeriodInMS) : 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;
+        dynamoConnectionParams.logger.debug({ dmpId, lastModified, now, gracePeriod, needToVersion }, 'Determining if we need to version the DMP');
         // 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);
+            await (0, exports.createDMP)(dynamoConnectionParams, domainName, 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) });
+        dynamoConnectionParams.logger.debug({ dmpId, versionItem }, 'Persisting DMP to DynamoDB');
         // Insert the RDA Common Standard metadata record into the DynamoDB table
-        await putItem((0, util_dynamodb_1.marshall)(versionItem, { removeUndefinedValues: true }));
+        await putItem(dynamoConnectionParams, (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);
+        await updateDMPExtensions(dynamoConnectionParams, 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];
+        return (await (0, exports.getDMPs)(dynamoConnectionParams, domainName, 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)}`);
+        const errMsg = (0, general_1.toErrorMessage)(err);
+        dynamoConnectionParams.logger.fatal({ dmpId, includeExtensions, errMsg }, 'Unable to update DMP -');
+        throw new DMPToolDynamoError(`Unable to update DMP id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION} - ${errMsg}`);
     }
 };
 exports.updateDMP = updateDMP;
@@ -410,20 +452,27 @@ 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 dynamoConnectionParams The DynamoDB connection parameters
+ * @param dmpId the DMP ID (e.g. 'doi.org/11.12345/A1B2C3D4')
  * @param dmp
  * @returns The persisted DMP Tool extensions metadata record.
  */
-const updateDMPExtensions = async (dmpId, dmp) => {
+const updateDMPExtensions = async (dynamoConnectionParams, dmpId, dmp) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0 || !dmp) {
+        throw new DMPToolDynamoError('Missing Dynamo config, DMP ID or DMP metadata record');
+    }
     // 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 }));
+    dynamoConnectionParams.logger.debug({ dmpId }, 'Persisting DMP Extensions to DynamoDB');
+    await putItem(dynamoConnectionParams, (0, util_dynamodb_1.marshall)(extensionItem, { removeUndefinedValues: true }));
 };
 /**
  * Create a Tombstone for the specified DMP metadata record
  * (registered/published DMPs only!)
  *
+ * @param dynamoConnectionParams The DynamoDB connection parameters
+ * @param domainName The domain name of the DMPTool instance (e.g. 'dmptool.org')
  * @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.
@@ -431,12 +480,16 @@ const updateDMPExtensions = async (dmpId, 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) => {
+const tombstoneDMP = async (dynamoConnectionParams, domainName, dmpId, includeExtensions = true) => {
     var _a, _b;
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0) {
+        throw new DMPToolDynamoError('Missing Dynamo config or DMP ID');
+    }
     // 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];
+    const dmp = (await (0, exports.getDMPs)(dynamoConnectionParams, domainName, dmpId, exports.DMP_LATEST_VERSION, true))[0];
     if (!dmp) {
+        dynamoConnectionParams.logger.error({ dmpId }, 'Unable to find current latest version of the 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
@@ -448,30 +501,34 @@ const tombstoneDMP = async (dmpId, includeExtensions = true) => {
         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)) {
+            dynamoConnectionParams.logger.error({ dmpId }, 'Unable to create modified date');
             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({
+            await putItem(dynamoConnectionParams, (0, util_dynamodb_1.marshall)(versionItem, { removeUndefinedValues: true }));
+            await deleteItem(dynamoConnectionParams, {
                 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);
+            await tombstoneDMPExtensions(dynamoConnectionParams, 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];
+            return (await (0, exports.getDMPs)(dynamoConnectionParams, domainName, 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)}`);
+            const errMsg = (0, general_1.toErrorMessage)(err);
+            dynamoConnectionParams.logger.fatal({ dmpId, errMsg }, 'Unable to tombstone DMP');
+            throw new DMPToolDynamoError(`Unable to tombstone id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION} - ${errMsg}`);
         }
     }
     else {
+        dynamoConnectionParams.logger.warn({ dmpId }, 'Unable to tombstone an unregistered DMP');
         throw new DMPToolDynamoError(`Unable to tombstone DMP id: ${dmpId} because it is not registered/published`);
     }
 };
@@ -480,20 +537,26 @@ exports.tombstoneDMP = tombstoneDMP;
  * Add a tombstone date to the specified DMP Extensions metadata record
  * (registered/published DMPs only!)
  *
+ * @param dynamoConnectionParams The DynamoDB connection parameters
  * @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 tombstoneDMPExtensions = async (dynamoConnectionParams, dmpId, dmp) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0 || !dmp) {
+        throw new DMPToolDynamoError('Missing Dynamo config, DMP ID or DMP metadata record');
+    }
     const now = (0, general_1.convertMySQLDateTimeToRFC3339)(new Date());
     if (!now) {
+        dynamoConnectionParams.logger.error({ dmpId }, 'Unable to create tombstone date');
         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 });
+    dynamoConnectionParams.logger.debug({ dmpId }, 'Tombstoning DMP Extensions in DynamoDB');
     // Update the DMP Tool Extensions metadata record
-    await putItem((0, util_dynamodb_1.marshall)(extensionItem, { removeUndefinedValues: true }));
+    await putItem(dynamoConnectionParams, (0, util_dynamodb_1.marshall)(extensionItem, { removeUndefinedValues: true }));
     // Then delete the old latest version
-    await deleteItem({
+    await deleteItem(dynamoConnectionParams, {
         PK: { S: dmpIdToPK(dmpId) },
         SK: { S: versionToExtensionSK(exports.DMP_LATEST_VERSION) }
     });
@@ -502,6 +565,8 @@ const tombstoneDMPExtensions = async (dmpId, dmp) => {
  * 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 dynamoConnectionParams The DynamoDB connection parameters
+ * @param domainName The domain name of the DMPTool instance (e.g. 'dmptool.org')
  * @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.
@@ -509,10 +574,13 @@ const tombstoneDMPExtensions = async (dmpId, dmp) => {
  * record with the DMP Tool specific extensions merged in.
  * @throws DMPToolDynamoError if the record could not be deleted
  */
-const deleteDMP = async (dmpId, includeExtensions = true) => {
+const deleteDMP = async (dynamoConnectionParams, domainName, dmpId, includeExtensions = true) => {
+    if (!dynamoConnectionParams || !dmpId || dmpId.trim().length === 0) {
+        throw new DMPToolDynamoError('Missing Dynamo config or DMP ID');
+    }
     // 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);
+    const dmps = await (0, exports.getDMPs)(dynamoConnectionParams, domainName, 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
@@ -524,45 +592,63 @@ const deleteDMP = async (dmpId, includeExtensions = true) => {
         // If the latest version was found, and it has NOT been registered/published
         if (latest && !latest.dmp.registered) {
             try {
+                dynamoConnectionParams.logger.debug({ dmpId }, 'Deleting DMP from DynamoDB');
                 // Delete all records with that DMP ID
-                await deleteItem({ PK: { S: dmpIdToPK(dmpId) } });
+                await deleteItem(dynamoConnectionParams, { 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)}`);
+                const errMsg = (0, general_1.toErrorMessage)(err);
+                dynamoConnectionParams.logger.fatal({ dmpId, errMsg }, 'Unable to delete DMP');
+                throw new DMPToolDynamoError(`Unable to delete id: ${dmpId}, ver: ${exports.DMP_LATEST_VERSION} - ${errMsg}`);
             }
         }
         else {
+            dynamoConnectionParams.logger.error({ dmpId }, 'Unable to delete an unregistered DMP');
             throw new DMPToolDynamoError(`Unable to delete id: ${dmpId} because it does not exist or is registered`);
         }
     }
     else {
+        dynamoConnectionParams.logger.error({ dmpId }, 'Unable to find current latest version of the DMP');
         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
+ *
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param params the query parameters
  * @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) => {
+const scanTable = async (dynamoConnectionParams, params) => {
+    if (!dynamoConnectionParams || !params) {
+        throw new DMPToolDynamoError('Missing Dynamo config or 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;
+        const command = new client_dynamodb_1.ScanCommand(Object.assign({ TableName: dynamoConnectionParams.tableName, ExclusiveStartKey: lastEvaluatedKey, ConsistentRead: false, ReturnConsumedCapacity: 'TOTAL' }, params));
+        try {
+            const dynamoDBClient = getDynamoDBClient(dynamoConnectionParams);
+            dynamoConnectionParams.logger.debug({ table: dynamoConnectionParams.tableName, params }, 'Scanning DynamoDB table');
+            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;
+        }
+        catch (error) {
+            const errMsg = (0, general_1.toErrorMessage)(error);
+            dynamoConnectionParams.logger.fatal(Object.assign(Object.assign(Object.assign({}, params), dynamoConnectionParams), { errMsg }), 'Unable to scan DynamoDB table');
+            throw new DMPToolDynamoError(`Unable to scan DynamoDB table - ${errMsg}`);
+        }
     } while (lastEvaluatedKey);
     // Deserialize and split items into multiple files if necessary
     return items;
@@ -570,23 +656,27 @@ const scanTable = async (table, params) => {
 /**
  * Query the specified DynamoDB table using the specified criteria
  *
+ * @param dynamoConnectionParams the DynamoDB connection parameters
  * @param params
  * @returns an array of DynamoDB items
  */
-const queryTable = async (params = {}) => {
+const queryTable = async (dynamoConnectionParams, 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));
+    const command = new client_dynamodb_1.QueryCommand(Object.assign({ TableName: dynamoConnectionParams.tableName, ConsistentRead: false, ReturnConsumedCapacity: 'TOTAL' }, params));
+    const dynamoDBClient = getDynamoDBClient(dynamoConnectionParams);
     return await dynamoDBClient.send(command);
 };
 /**
  * Create/Update an item in the specified DynamoDB table
  *
- * @param item
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param item the item to insert/update
  */
-const putItem = async (item) => {
+const putItem = async (dynamoConnectionParams, item) => {
+    const dynamoDBClient = getDynamoDBClient(dynamoConnectionParams);
     // Delete the item from the DynamoDB table
     await dynamoDBClient.send(new client_dynamodb_1.PutItemCommand({
-        TableName: process.env.DYNAMO_TABLE_NAME,
+        TableName: dynamoConnectionParams.tableName,
         ReturnConsumedCapacity: 'TOTAL',
         Item: item
     }));
@@ -595,12 +685,14 @@ const putItem = async (item) => {
 /**
  * Delete an item from the specified DynamoDB table
  *
- * @param key
+ * @param dynamoConnectionParams the DynamoDB connection parameters
+ * @param key the partition (and sort key if applicable) of the item to delete
  */
-const deleteItem = async (key) => {
+const deleteItem = async (dynamoConnectionParams, key) => {
+    const dynamoDBClient = getDynamoDBClient(dynamoConnectionParams);
     // Delete the item from the DynamoDB table
     await dynamoDBClient.send(new client_dynamodb_1.DeleteItemCommand({
-        TableName: process.env.DYNAMO_TABLE_NAME,
+        TableName: dynamoConnectionParams.tableName,
         ReturnConsumedCapacity: 'TOTAL',
         Key: key
     }));

package/dist/eventBridge.d.ts

@@ -1,3 +1,4 @@
+import { Logger } from 'pino';
 export interface PutEventResponse {
     status: number;
     message: string;
@@ -6,8 +7,9 @@ export interface PutEventResponse {
 /**
  * Publishes an event to EventBridge.
  *
+ * @param logger The logger to use for logging.
  * @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>;
+export declare const putEvent: (logger: Logger, busName: string, source: string, detailType: string, details: Record<string, unknown>, region?: string) => Promise<PutEventResponse>;