@plusscommunities/pluss-core-aws 2.0.25-auth.0 → 2.0.25-beta.1

package/helper/notifySiteConfigs.js

@@ -0,0 +1,132 @@
+/**
+ * Notify SiteConfigs Service of Operational Data Changes
+ *
+ * This helper provides a pre-filtering mechanism for auto-propagation.
+ * When operational data changes (sites, usertypes, interfaces, strings, jobTypes),
+ * this function:
+ *
+ * 1. Queries SourceSiteIdIndex to check if any templates use this site as source
+ * 2. If none found → early return (no Lambda invoke, 99% of cases)
+ * 3. If templates found → invokes siteConfigs Lambda to handle republishing
+ *
+ * This hybrid approach ensures:
+ * - No Lambda latency for most sites (pre-filter catches non-source sites)
+ * - Publishing logic stays encapsulated in siteConfigs service
+ * - Minimal cross-service coupling
+ *
+ * Usage:
+ *   const notifySiteConfigs = require("@plusscommunities/pluss-core-aws/helper/notifySiteConfigs");
+ *   await notifySiteConfigs(siteId, logId);
+ */
+
+const AWS = require("aws-sdk");
+const indexQuery = require("../db/common/indexQuery");
+const { log } = require("./index");
+
+const lambda = new AWS.Lambda();
+
+const TABLE_NAME = "siteconfigs";
+
+/**
+ * Check if a site has any templates using it as a source
+ * @param {string} siteId - The site ID to check
+ * @returns {Promise<Array>} Array of template IDs (empty if none)
+ */
+const getTemplatesForSourceSite = async (siteId) => {
+	try {
+		const result = await indexQuery(TABLE_NAME, {
+			IndexName: "SourceSiteIdIndex",
+			KeyConditionExpression: "SourceSiteId = :sourceSiteId",
+			ExpressionAttributeValues: {
+				":sourceSiteId": siteId,
+			},
+			ProjectionExpression: "Id", // Only need IDs for pre-filter
+		});
+		return (result.Items || []).map((item) => item.Id);
+	} catch (err) {
+		// Table or index might not exist in all deployments
+		log("notifySiteConfigs", "QueryError", { siteId, error: err.message });
+		return [];
+	}
+};
+
+/**
+ * Invoke the siteConfigs operationalDataChanged Lambda
+ * @param {string} siteId - The source site that changed
+ * @param {Array<string>} templateIds - List of template IDs to republish
+ * @param {string} logId - Log ID for tracing
+ */
+const invokeSiteConfigsLambda = async (siteId, templateIds, logId) => {
+	// Build function name from environment
+	// Format: {client}-siteConfigs-{stage}-operationalDataChanged
+	const client = process.env.client || "dev";
+	const stage = process.env.stage || "dev";
+	const functionName = `${client}-siteConfigs-${stage}-operationalDataChanged`;
+
+	const payload = {
+		siteId,
+		templateIds,
+		logId,
+		source: "notifySiteConfigs",
+	};
+
+	log(
+		"notifySiteConfigs",
+		"InvokingLambda",
+		{ functionName, siteId, templateCount: templateIds.length },
+		logId,
+	);
+
+	try {
+		await lambda
+			.invoke({
+				FunctionName: functionName,
+				InvocationType: "Event", // Async invocation
+				Payload: JSON.stringify(payload),
+			})
+			.promise();
+
+		log("notifySiteConfigs", "LambdaInvoked", { functionName, siteId }, logId);
+	} catch (err) {
+		log(
+			"notifySiteConfigs",
+			"LambdaError",
+			{ functionName, siteId, error: err.message },
+			logId,
+		);
+		// Don't throw - this is a non-critical operation
+	}
+};
+
+/**
+ * Notify siteConfigs service that operational data has changed for a site.
+ * Performs pre-filtering to avoid unnecessary Lambda invocations.
+ *
+ * @param {string} siteId - The site ID where operational data changed
+ * @param {string} logId - Optional log ID for tracing
+ */
+const notifySiteConfigs = async (siteId, logId) => {
+	if (!siteId) {
+		return;
+	}
+
+	// Pre-filter: Check if this site is a source for any templates
+	const templateIds = await getTemplatesForSourceSite(siteId);
+
+	if (templateIds.length === 0) {
+		// No Lambda invocation needed
+		return;
+	}
+
+	log(
+		"notifySiteConfigs",
+		"TemplatesFound",
+		{ siteId, count: templateIds.length },
+		logId,
+	);
+
+	// Invoke siteConfigs Lambda to handle republishing
+	await invokeSiteConfigsLambda(siteId, templateIds, logId);
+};
+
+module.exports = notifySiteConfigs;

package/helper/opengraph/getOpenGraph.js

@@ -2,17 +2,17 @@ const axios = require("axios");
 const { getConfig } = require("../../config");
 
 module.exports = async (url) => {
-  return new Promise(async (resolve, reject) => {
-    const request = {
-      method: "GET",
-      url: `https://opengraph.io/api/1.1/site/${encodeURIComponent(url)}?app_id=${getConfig().thirdPartyAPIKeys.openGraph}`,
-    };
+	return new Promise(async (resolve, reject) => {
+		const request = {
+			method: "GET",
+			url: `https://opengraph.io/api/1.1/site/${encodeURIComponent(url)}?app_id=${getConfig().thirdPartyAPIKeys.openGraph}`,
+		};
 
-    try {
-      const response = await axios(request);
-      return resolve(response.data);
-    } catch (e) {
-      return reject(e);
-    }
-  });
+		try {
+			const response = await axios(request);
+			return resolve(response.data);
+		} catch (e) {
+			return reject(e);
+		}
+	});
 };

package/helper/rates/checkRateLimit.js

@@ -12,45 +12,45 @@ const updateRef = require("../../db/common/updateRef");
  * @returns {Boolean} true if this call is fine. false if the call should be restricted due to rate limits.
  */
 module.exports = async (rateLimitId, timeframe, limit, noSave) => {
-  const logId = log("checkRateLimit", "Input", {
-    rateLimitId,
-    timeframe,
-    limit,
-  });
+	const logId = log("checkRateLimit", "Input", {
+		rateLimitId,
+		timeframe,
+		limit,
+	});
 
-  // get rate limit item
-  const item = await getRef("ratelimit", "Id", rateLimitId);
-  const now = moment().valueOf();
-  const minTime = now - timeframe;
+	// get rate limit item
+	const item = await getRef("ratelimit", "Id", rateLimitId);
+	const now = moment().valueOf();
+	const minTime = now - timeframe;
 
-  const history = item && item.History ? item.History : [];
+	const history = item && item.History ? item.History : [];
 
-  if (history) {
-    // check history for entries to determine whether limit is surpassed
-    const entriesInTimeLimit = history.filter((e) => e > minTime);
-    log(
-      "checkRateLimit",
-      "entriesInTimeLimit",
-      entriesInTimeLimit.length,
-      logId
-    );
-    if (entriesInTimeLimit.length >= limit) {
-      // Limit surpassed
-      log("checkRateLimit", "Return", false, logId);
-      return false;
-    }
-  }
+	if (history) {
+		// check history for entries to determine whether limit is surpassed
+		const entriesInTimeLimit = history.filter((e) => e > minTime);
+		log(
+			"checkRateLimit",
+			"entriesInTimeLimit",
+			entriesInTimeLimit.length,
+			logId,
+		);
+		if (entriesInTimeLimit.length >= limit) {
+			// Limit surpassed
+			log("checkRateLimit", "Return", false, logId);
+			return false;
+		}
+	}
 
-  // check whether to save the current entry - used for when checking multiple timeframes such as X calls in a minute and X calls in a day
-  if (!noSave) {
-    history.push(now);
-    updateRef("ratelimit", {
-      Id: rateLimitId,
-      LastSent: now,
-      History: history,
-    });
-  }
-  // Limit is fine
-  log("checkRateLimit", "Return", true, logId);
-  return true;
-};
+	// check whether to save the current entry - used for when checking multiple timeframes such as X calls in a minute and X calls in a day
+	if (!noSave) {
+		history.push(now);
+		updateRef("ratelimit", {
+			Id: rateLimitId,
+			LastSent: now,
+			History: history,
+		});
+	}
+	// Limit is fine
+	log("checkRateLimit", "Return", true, logId);
+	return true;
+};

package/helper/requestToSource.js

@@ -3,14 +3,14 @@ const _ = require("lodash");
 
 // sends a request to the Pluss Source API
 module.exports = (method, service, endpoint, query, data) => {
-  return axios({
-    method,
-    url: `https://pluss60.pluss60-api.com/${service}-demo/${endpoint}${
-      !_.isEmpty(query) ? query : ""
-    }`,
-    data,
-    headers: {
-      Authorization: "SmartCommunities",
-    },
-  });
+	return axios({
+		method,
+		url: `https://pluss60.pluss60-api.com/${service}-demo/${endpoint}${
+			!_.isEmpty(query) ? query : ""
+		}`,
+		data,
+		headers: {
+			Authorization: "SmartCommunities",
+		},
+	});
 };

package/helper/sendEmail.js

@@ -8,98 +8,98 @@ const getRef = require("../db/common/getRef");
 const updateRef = require("../db/common/updateRef");
 
 const sendFallback = (mailOptions, emailConfig, accessConfig) => {
-  return new Promise((resolve, reject) => {
-    const logId = log("sendFallback", "Email", mailOptions);
-    if (emailConfig.isFallback) {
-      log(
-        "sendFallback",
-        "isFallback",
-        "Not allowed to use this account as it is the fallback itself",
-        logId
-      );
-      return reject(
-        new Error(
-          "Not allowed to use this account as it is the fallback itself"
-        )
-      );
-    }
+	return new Promise((resolve, reject) => {
+		const logId = log("sendFallback", "Email", mailOptions);
+		if (emailConfig.isFallback) {
+			log(
+				"sendFallback",
+				"isFallback",
+				"Not allowed to use this account as it is the fallback itself",
+				logId,
+			);
+			return reject(
+				new Error(
+					"Not allowed to use this account as it is the fallback itself",
+				),
+			);
+		}
 
-    // Calling organisation account as the fallback
-    log("sendFallback", "Fallback", emailConfig.fallbackUrl, logId);
-    axios({
-      method: "POST",
-      url: emailConfig.fallbackUrl,
-      headers: {
-        Authorization: accessConfig.authSecret,
-      },
-      data: {
-        to: mailOptions.to,
-        subject: mailOptions.subject,
-        body: mailOptions.html,
-        from: mailOptions.from,
-      },
-    })
-      .then((response) => {
-        log("sendFallback", "response", response.data, logId);
-        resolve(response.data);
-      })
-      .catch((error) => {
-        log("sendFallback", "error", error, logId);
-        reject(error);
-      });
-  });
+		// Calling organisation account as the fallback
+		log("sendFallback", "Fallback", emailConfig.fallbackUrl, logId);
+		axios({
+			method: "POST",
+			url: emailConfig.fallbackUrl,
+			headers: {
+				Authorization: accessConfig.authSecret,
+			},
+			data: {
+				to: mailOptions.to,
+				subject: mailOptions.subject,
+				body: mailOptions.html,
+				from: mailOptions.from,
+			},
+		})
+			.then((response) => {
+				log("sendFallback", "response", response.data, logId);
+				resolve(response.data);
+			})
+			.catch((error) => {
+				log("sendFallback", "error", error, logId);
+				reject(error);
+			});
+	});
 };
 
 module.exports = async (
-  toEmail,
-  subject,
-  content,
-  useTemplate,
-  {
-    fromEmail = null,
-    excludeClientBranding = false,
-    brandingImage = null,
-    bcc = null,
-    rateLimitId = null,
-  } = {}
+	toEmail,
+	subject,
+	content,
+	useTemplate,
+	{
+		fromEmail = null,
+		excludeClientBranding = false,
+		brandingImage = null,
+		bcc = null,
+		rateLimitId = null,
+	} = {},
 ) => {
-  const { communityConfig, serverlessConfig, emailConfig, accessConfig } =
-    getConfig();
-  const now = moment.utc();
-  let rateLimitIdToUse;
+	const { communityConfig, serverlessConfig, emailConfig, accessConfig } =
+		getConfig();
+	const now = moment.utc();
+	let rateLimitIdToUse;
 
-  const logId = log("sendEmail", "Email", {
-    toEmail,
-    subject,
-  });
+	const logId = log("sendEmail", "Email", {
+		toEmail,
+		subject,
+	});
 
-  if (rateLimitId) {
-    try {
-      rateLimitIdToUse = `email_${rateLimitId}`;
-      const item = await getRef("ratelimit", "Id", rateLimitIdToUse);
-      const dayAgo = moment(now).add(-1, "d");
-      if (item && item.LastSent && item.LastSent > dayAgo.valueOf()) {
-        log(
-          "sendEmail",
-          "RateLimit",
-          `Rate limit reached for ${rateLimitIdToUse}`,
-          logId
-        );
-        return { RateLimited: true };
-      }
-    } catch (e) {
-      // continue
-    }
-  }
+	if (rateLimitId) {
+		try {
+			rateLimitIdToUse = `email_${rateLimitId}`;
+			const item = await getRef("ratelimit", "Id", rateLimitIdToUse);
+			const dayAgo = moment(now).add(-1, "d");
+			if (item && item.LastSent && item.LastSent > dayAgo.valueOf()) {
+				log(
+					"sendEmail",
+					"RateLimit",
+					`Rate limit reached for ${rateLimitIdToUse}`,
+					logId,
+				);
+				return { RateLimited: true };
+			}
+		} catch (e) {
+			// continue
+		}
+	}
 
-  if (useTemplate) {
-    content = `<div style="padding: 24px; padding-top: 0px; background-color: #f2f4f8;margin: 0px;">
+	if (useTemplate) {
+		content = `<div style="padding: 24px; padding-top: 0px; background-color: #f2f4f8;margin: 0px;">
                     <div style="background-color: #fff; padding: 48px; padding-top: 65px; padding-bottom: 24px;">
                         ${content}
                         ${
-                          excludeClientBranding
-                            ? ""
-                            : `
+													excludeClientBranding
+														? ""
+														: `
                             <div style='margin-top: 32px; border-top: 2px solid #e0e0e0;'></div>
                             <div style='padding-top: 24px;  display: block;'>
                                 <div style='clear: both; height: 30px;'>
@@ -107,7 +107,7 @@ module.exports = async (
                                 </div>
                             </div>
                         `
-                        }
+												}
                     </div>
                     <div style='margin-top: 30px;'>
                       <div style='margin: 0 auto; width: fit-content;'>
@@ -118,46 +118,46 @@ module.exports = async (
                       </div>
                     </div>
                 </div>`;
-  }
+	}
 
-  const sesInfo = await getEmailServiceInfo(
-    serverlessConfig.key,
-    serverlessConfig.secret
-  );
+	const sesInfo = await getEmailServiceInfo(
+		serverlessConfig.key,
+		serverlessConfig.secret,
+	);
 
-  const mailOptions = {
-    from: fromEmail || `${communityConfig.name} <${sesInfo.sender}>`,
-    to: toEmail,
-    bcc,
-    subject,
-    text: content,
-    html: content,
-  };
+	const mailOptions = {
+		from: fromEmail || `${communityConfig.name} <${sesInfo.sender}>`,
+		to: toEmail,
+		bcc,
+		subject,
+		text: content,
+		html: content,
+	};
 
-  if (sesInfo.enabled) {
-    try {
-      log("sendEmail", "SES", { toEmail, subject }, logId);
-      const result = await sendEmail(
-        mailOptions.from,
-        mailOptions.to,
-        mailOptions.subject,
-        mailOptions.html,
-        serverlessConfig,
-        mailOptions.bcc
-      );
-      log("sendEmail", "Success", { toEmail, subject }, logId);
-    } catch (error) {
-      log("sendEmail", "Error:SES", { toEmail, subject, error }, logId);
-      await sendFallback(mailOptions, emailConfig, accessConfig);
-    }
-  } else {
-    await sendFallback(mailOptions, emailConfig, accessConfig);
-  }
+	if (sesInfo.enabled) {
+		try {
+			log("sendEmail", "SES", { toEmail, subject }, logId);
+			const result = await sendEmail(
+				mailOptions.from,
+				mailOptions.to,
+				mailOptions.subject,
+				mailOptions.html,
+				serverlessConfig,
+				mailOptions.bcc,
+			);
+			log("sendEmail", "Success", { toEmail, subject }, logId);
+		} catch (error) {
+			log("sendEmail", "Error:SES", { toEmail, subject, error }, logId);
+			await sendFallback(mailOptions, emailConfig, accessConfig);
+		}
+	} else {
+		await sendFallback(mailOptions, emailConfig, accessConfig);
+	}
 
-  if (rateLimitIdToUse) {
-    await updateRef("ratelimit", {
-      Id: rateLimitIdToUse,
-      LastSent: now.valueOf(),
-    });
-  }
+	if (rateLimitIdToUse) {
+		await updateRef("ratelimit", {
+			Id: rateLimitIdToUse,
+			LastSent: now.valueOf(),
+		});
+	}
 };

package/helper/templates/replacePlaceHolders.js

@@ -1,32 +1,32 @@
 module.exports = (template, toReplace = null, user = null) => {
-  let replaced = template;
-  if (toReplace) {
-    Object.keys(toReplace).forEach((key) => {
-      replaced = replaced.replace(
-        new RegExp(`{{${key}}}`, "g"),
-        toReplace[key] || ""
-      );
-    });
-  }
-  if (user) {
-    const nameReplace =
-      (toReplace?.names && toReplace?.names[user.Id]) || user.displayName;
-    const phoneReplace =
-      (toReplace?.phoneNumbers && toReplace?.phoneNumbers[user.Id]) ||
-      user.phoneNumber;
-    // Remove surname
-    const firstname = nameReplace
-      ? nameReplace.split(" ").map((n) => n.trim())[0]
-      : null;
-    replaced = replaced
-      .replace(new RegExp("{{name}}", "g"), firstname || "{{name}}")
-      .replace(new RegExp("{{fullname}}", "g"), nameReplace || "{{fullname}}")
-      .replace(
-        new RegExp("{{phoneNumber}}", "g"),
-        phoneReplace || "{{phoneNumber}}"
-      )
-      .replace(new RegExp("{{email}}", "g"), user.email || "{{email}}");
-  }
+	let replaced = template;
+	if (toReplace) {
+		Object.keys(toReplace).forEach((key) => {
+			replaced = replaced.replace(
+				new RegExp(`{{${key}}}`, "g"),
+				toReplace[key] || "",
+			);
+		});
+	}
+	if (user) {
+		const nameReplace =
+			(toReplace?.names && toReplace?.names[user.Id]) || user.displayName;
+		const phoneReplace =
+			(toReplace?.phoneNumbers && toReplace?.phoneNumbers[user.Id]) ||
+			user.phoneNumber;
+		// Remove surname
+		const firstname = nameReplace
+			? nameReplace.split(" ").map((n) => n.trim())[0]
+			: null;
+		replaced = replaced
+			.replace(new RegExp("{{name}}", "g"), firstname || "{{name}}")
+			.replace(new RegExp("{{fullname}}", "g"), nameReplace || "{{fullname}}")
+			.replace(
+				new RegExp("{{phoneNumber}}", "g"),
+				phoneReplace || "{{phoneNumber}}",
+			)
+			.replace(new RegExp("{{email}}", "g"), user.email || "{{email}}");
+	}
 
-  return replaced;
+	return replaced;
 };

package/helper/time/getLocalTimestamp.js

@@ -1,25 +1,25 @@
 const moment = require("moment-timezone");
 
 module.exports = (dateString, timeOfDay, timezone, resultFormat = "value") => {
-  // Parse the date string into a moment object in the given timezone
-  const dateMoment = moment.tz(dateString, "DD-MM-YYYY", timezone);
+	// Parse the date string into a moment object in the given timezone
+	const dateMoment = moment.tz(dateString, "DD-MM-YYYY", timezone);
 
-  // Calculate the hours and minutes from the timeOfDay in minutes
-  const hours = Math.floor(timeOfDay / 60);
-  const minutes = timeOfDay % 60;
+	// Calculate the hours and minutes from the timeOfDay in minutes
+	const hours = Math.floor(timeOfDay / 60);
+	const minutes = timeOfDay % 60;
 
-  // Set the hours and minutes to the dateMoment
-  dateMoment.hours(hours).minutes(minutes).seconds(0).milliseconds(0);
+	// Set the hours and minutes to the dateMoment
+	dateMoment.hours(hours).minutes(minutes).seconds(0).milliseconds(0);
 
-  switch (resultFormat) {
-    case "string":
-      // return the timestamp in string format
-      return dateMoment.format();
-    case "value":
-      // Return the timestamp in milliseconds
-      return dateMoment.valueOf();
-    default:
-      // return the timestamp in a formatted string
-      return dateMoment.format(resultFormat);
-  }
+	switch (resultFormat) {
+		case "string":
+			// return the timestamp in string format
+			return dateMoment.format();
+		case "value":
+			// Return the timestamp in milliseconds
+			return dateMoment.valueOf();
+		default:
+			// return the timestamp in a formatted string
+			return dateMoment.format(resultFormat);
+	}
 };