@plusscommunities/pluss-core-aws 2.0.25-beta.6 → 2.0.25-beta.8

package/helper/hqPublishing.js

@@ -144,17 +144,43 @@ const fanOutHqSource = async (hqSourceRow, tableName) => {
 	if (targets.length === 0) {
 		return [];
 	}
+	return writeCopiesForTargets(hqSourceRow, targets, tableName);
+};
+
+/**
+ * Write one community-copy row per site in `targetSites` (all of the source's
+ * PublishedToSites on INSERT fan-out, or just the newly-added subset on a
+ * MODIFY target-set change). Shared by fanOutHqSource and syncHqTargets. The
+ * deterministic RowId makes each write idempotent AND makes re-adding a
+ * previously-removed (soft-deleted) site a lossless resurrection — the PUT
+ * overwrites the row and drops the Deleted flag.
+ *
+ * @param {object} hqSourceRow — the HQ-source row.
+ * @param {string[]} targetSites — sites to write copies for.
+ * @param {string} tableName — entity's table name.
+ * @returns {Promise<object[]>} the copy rows written.
+ */
+const writeCopiesForTargets = (hqSourceRow, targetSites, tableName) => {
 	const copyId = `hqcopy-${hqSourceRow.Id}`;
-	// IMPORTANT: milliseconds (.valueOf), not seconds (.unix). Newsletter
-	// rows written by addNewsletterEntry.js use `moment.utc().valueOf()` for
-	// UnixTimestamp. UnixTimestampReverse-keyed feed queries (the standard
-	// Pluss list pattern) would otherwise rank HQ copies ~1000× ahead of
-	// locally-authored posts forever — MAX_SAFE_INTEGER minus a number 10^9
-	// is vastly larger than MAX_SAFE_INTEGER minus 10^12. Keep parity with
-	// the canonical addNewsletterEntry convention.
+	// Preserve the HQ-source row's own UnixTimestamp on each copy rather than
+	// stamping "now". For an immediate publish the source timestamp already IS
+	// ~now, so feed ranking is unchanged; for a SCHEDULED publish (future
+	// timestamp set via the compose "Schedule Post" tab) preserving it keeps the
+	// copies hidden until the scheduled moment — BOTH consumers key off it: the
+	// noFuture feed filter, and the deferred-notification scheduler
+	// (watchNewsletter / the INSERT-path checkSendNotifications both gate on
+	// `UnixTimestamp < now`). Stamping "now" here published scheduled HQ posts
+	// (feed + push) immediately, ignoring the schedule. Fall back to now only if
+	// the source somehow lacks a timestamp.
+	//
+	// IMPORTANT: milliseconds (.valueOf), not seconds (.unix) — parity with the
+	// addNewsletterEntry UnixTimestamp convention. UnixTimestampReverse-keyed
+	// feed queries would otherwise mis-rank an ms value against a seconds value
+	// (MAX_SAFE_INTEGER minus 10^9 vs minus 10^12).
 	const now = moment.utc().valueOf();
+	const publishTs = hqSourceRow.UnixTimestamp || now;
 
-	const writes = targets.map((targetSiteId) => {
+	const writes = targetSites.map((targetSiteId) => {
 		// Spread + override pattern: keep all content fields, swap identity
 		// fields, drop HQ-only fields. Spread is shallow — nested objects
 		// (Author, etc.) share references with the source row, which is fine
@@ -164,8 +190,8 @@ const fanOutHqSource = async (hqSourceRow, tableName) => {
 		copy.Site = targetSiteId;
 		copy.RowId = `${targetSiteId}_${copyId}`;
 		copy.HqSourceId = hqSourceRow.Id;
-		copy.UnixTimestamp = now;
-		copy.UnixTimestampReverse = Number.MAX_SAFE_INTEGER - now;
+		copy.UnixTimestamp = publishTs;
+		copy.UnixTimestampReverse = Number.MAX_SAFE_INTEGER - publishTs;
 		// Each copy's own INSERT fires publishNotifications via the existing
 		// pipeline. Setting UnsentNotification: "X" matches the convention
 		// used by addNewsletterEntry when caller requested a notification.
@@ -173,11 +199,73 @@ const fanOutHqSource = async (hqSourceRow, tableName) => {
 		// HQ-only fields don't travel:
 		delete copy.PublishedToSites;
 		delete copy.Deleted;     // copies start undeleted; retract cascade is separate
+		// Tagged references HQ-site users; on a community copy those IDs are
+		// orphaned (cosmetic "tagged people" display + a createUserEntries write
+		// keyed on non-members in newsletterChanged's INSERT branch). Audience
+		// targeting (All/Category) already governs who sees the copy.
+		delete copy.Tagged;
 		return updateRef(tableName, copy).then(() => copy);
 	});
 	return Promise.all(writes);
 };
 
+/**
+ * Reconcile community copies when an HQ-source MODIFY changes PublishedToSites:
+ * fan out copies for newly-ADDED sites, soft-delete copies for REMOVED sites.
+ * Content propagation to surviving copies is propagateHqEdit's job; this only
+ * reconciles the target SET. Re-adding a removed site resurrects its copy
+ * losslessly (deterministic RowId + PUT — see writeCopiesForTargets).
+ *
+ * MUST run sequentially relative to propagateHqEdit (never concurrently): both
+ * use editRef (get-merge-put), and two concurrent writes to the same removed-
+ * copy RowId would race (one clobbering the other's Deleted flag).
+ *
+ * @param {object} prevRow — OldImage of the HQ-source row.
+ * @param {object} nextRow — NewImage of the HQ-source row.
+ * @param {string} tableName — entity's table name.
+ * @param {object} [options]
+ * @param {string} [options.indexName="NewsletterEntriesHqSourceIdIndex"]
+ * @returns {Promise<{added: number, removed: number}>}
+ */
+const syncHqTargets = async (prevRow, nextRow, tableName, options = {}) => {
+	const indexName = options.indexName || "NewsletterEntriesHqSourceIdIndex";
+	if (!nextRow || nextRow.Site !== "hq" || nextRow.Deleted) {
+		return { added: 0, removed: 0 };
+	}
+	const prev = Array.isArray(prevRow?.PublishedToSites)
+		? prevRow.PublishedToSites
+		: [];
+	const next = Array.isArray(nextRow.PublishedToSites)
+		? nextRow.PublishedToSites
+		: [];
+	const added = next.filter((s) => !prev.includes(s));
+	const removed = prev.filter((s) => !next.includes(s));
+
+	if (added.length > 0) {
+		await writeCopiesForTargets(nextRow, added, tableName);
+	}
+	if (removed.length > 0) {
+		const copies = await findCopiesByHqSourceId(
+			nextRow.Id,
+			tableName,
+			indexName,
+		);
+		const toRemove = copies.filter((c) => removed.includes(c.Site));
+		// Per-call fresh payload — editRef sync-mutates updates[keyCol]; sharing
+		// across Promise.all(map) would leak RowId between iterations (same
+		// rationale as propagateHqEdit / cascadeHqRetract).
+		await Promise.all(
+			toRemove.map((c) =>
+				editRef(tableName, "RowId", c.RowId, {
+					Deleted: true,
+					Changed: moment.utc().unix(),
+				}),
+			),
+		);
+	}
+	return { added: added.length, removed: removed.length };
+};
+
 /**
  * Propagate an HQ-source MODIFY to every community copy via the GSI lookup.
  * Skips the retract case (where `Deleted: true`) — that flows through
@@ -312,8 +400,8 @@ const cascadeHqRetract = async (hqSourceRow, tableName, options = {}) => {
  * @param {string} templateId — the `Id` of the contentLibrary row.
  * @param {string} contentLibraryTable — entity-agnostic; caller passes the
  *   table name (without prefix).
- * @returns {Promise<boolean>} `true` if increment applied; `false` on graceful
- *   skip (table not shipped yet, or no template with that Id exists).
+ * @returns {Promise<boolean>} `true` if increment applied; `false` if table
+ *   doesn't exist (graceful skip).
  */
 const incrementTemplateUseCount = async (templateId, contentLibraryTable) => {
 	if (!templateId || !contentLibraryTable) {
@@ -322,16 +410,11 @@ const incrementTemplateUseCount = async (templateId, contentLibraryTable) => {
 	const params = {
 		TableName: `${process.env.tablePrefix}${contentLibraryTable}`,
 		Key: { Id: templateId },
-		UpdateExpression: "ADD UseCount :inc SET LastUsedTimestamp = :now",
-		// Guard against minting a phantom row: ADD on a missing key would CREATE
-		// it with UseCount=1. Only increment a template that actually exists; a
-		// stale/bogus TemplateId is skipped (ConditionalCheckFailed below).
-		ConditionExpression: "attribute_exists(Id)",
+		UpdateExpression:
+			"ADD UseCount :inc SET LastUsedTimestamp = :now",
 		ExpressionAttributeValues: {
 			":inc": 1,
-			// epoch ms — the contentLibrary timestamp convention (matches
-			// UpdatedAt). Was .unix() (seconds); reconciled to .valueOf().
-			":now": moment().utc().valueOf(),
+			":now": moment.utc().unix(),
 		},
 	};
 	try {
@@ -349,12 +432,6 @@ const incrementTemplateUseCount = async (templateId, contentLibraryTable) => {
 			);
 			return false;
 		}
-		if (error?.code === "ConditionalCheckFailedException") {
-			// TemplateId references no existing template — skip rather than
-			// create a phantom row. Not an error; continue the stream handler.
-			log("incrementTemplateUseCount", "NoSuchTemplate", { templateId });
-			return false;
-		}
 		// Anything else is genuinely unexpected — surface it.
 		log("incrementTemplateUseCount", "Error", error);
 		throw error;
@@ -367,6 +444,8 @@ module.exports = {
 	// Story B
 	findCopiesByHqSourceId,
 	fanOutHqSource,
+	writeCopiesForTargets,
+	syncHqTargets,
 	propagateHqEdit,
 	cascadeHqRetract,
 	incrementTemplateUseCount,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@plusscommunities/pluss-core-aws",
-	"version": "2.0.25-beta.6",
+	"version": "2.0.25-beta.8",
 	"description": "Core extension package for Pluss Communities platform",
 	"scripts": {
 		"betapatch": "npm version prepatch --preid=beta",