@pkcprotocol/pkc-js 0.0.112 → 0.0.113

package/dist/node/runtime/node/community/db-handler.js

@@ -1598,14 +1598,19 @@ export class DbHandler {
     _collectCommentsToBeUpdated() {
         const windowed = this._buildWindowedReplySortArms(timestamp());
         const notPending = (alias) => `(${alias}.pendingApproval IS NULL OR ${alias}.pendingApproval != 1)`;
-        // A child that counts towards its parent's childCount: has a CommentUpdate, not removed, not deleted by its author
+        const countedChildAddress = this._communityAddressClauseNamed("c", "countedChild");
+        // A child that counts towards its parent's childCount: has a CommentUpdate and this community's address, not
+        // removed, not deleted by its author, not disapproved (the rule _queryReplyCountsByParentCids and
+        // _queryLastChildCidsByParentCids apply, or the parent is re-flagged every cycle)
         const countedChild = `
                 FROM ${TABLES.COMMENTS} c
                 JOIN ${TABLES.COMMENT_UPDATES} cu_child ON c.cid = cu_child.cid
                 WHERE c.parentCid IS NOT NULL
+                  AND ${countedChildAddress.clause}
                   AND ${notPending("c")}
                   AND (cu_child.removed IS NOT 1 AND cu_child.removed IS NOT TRUE)
-                  AND (json_extract(cu_child.edit, '$.deleted') IS NULL OR json_extract(cu_child.edit, '$.deleted') != 1)`;
+                  AND (json_extract(cu_child.edit, '$.deleted') IS NULL OR json_extract(cu_child.edit, '$.deleted') != 1)
+                  AND COALESCE(cu_child.approved, 1) != 0`;
         const insert = `INSERT OR IGNORE INTO ${COMMENTS_TO_UPDATE_TEMP_TABLE}`;
         const arms = [
             `${insert}
@@ -1637,7 +1642,6 @@ export class DbHandler {
             WITH last_child_rowids AS (
                 SELECT c.parentCid AS cid, MAX(c.rowid) AS last_child_rowid
                 ${countedChild}
-                  AND COALESCE(cu_child.approved, 1) != 0
                 GROUP BY c.parentCid
             )
             SELECT parent.rowid
@@ -1685,9 +1689,11 @@ export class DbHandler {
             )
             SELECT id FROM parent_chain`
         ];
+        const allParams = { ...windowed.params, ...countedChildAddress.params };
         for (const arm of arms) {
-            // Each statement is bound only to the named parameters it mentions (the windowed arms' window bounds)
-            const params = Object.fromEntries(Object.entries(windowed.params).filter(([name]) => arm.includes(`:${name}`)));
+            // Each statement is bound only to the named parameters it mentions (the windowed arms' window bounds, the
+            // counted-child address)
+            const params = Object.fromEntries(Object.entries(allParams).filter(([name]) => arm.includes(`:${name}`)));
             this._prepareCached(arm).run(params);
         }
     }
@@ -2294,79 +2300,88 @@ export class DbHandler {
         }
         return result;
     }
-    // replyCount and childCount of every parent in one recursive walk anchored on all of them: a descendant counts
-    // when every comment on the path from the parent has a CommentUpdate, this community's address, and is neither
-    // removed nor deleted; childCount is the level-1 part of the same walk.
+    // Whether a comment in a reply walk is present (neither removed, deleted nor disapproved), over the cu and d aliases
+    // the walks join. A comment that is not present is skipped by the counts but still walked through: reply pages keep
+    // it as a tombstone, so the present replies under it are still part of the thread (#405). A disapproved comment
+    // never has replies under it, since publishing under a pending or disapproved comment is rejected.
+    _replyWalkPresentExpression() {
+        return `CASE WHEN (cu.removed IS NOT 1 AND cu.removed IS NOT TRUE) AND (d.deleted_flag IS NULL OR d.deleted_flag != 1) AND COALESCE(cu.approved, 1) != 0 THEN 1 ELSE 0 END`;
+    }
+    // replyCount and childCount of every parent in one recursive walk anchored on all of them: the walk follows every
+    // descendant whose path from the parent has a CommentUpdate and this community's address, and a descendant counts
+    // when it is also present (neither removed, deleted nor disapproved); childCount is the level-1 part of the same count.
     _queryReplyCountsByParentCids(parentCids) {
         const result = new Map();
         const { clause: addrClause, params: addrParams } = this._communityAddressClause("c");
-        const passes = `${addrClause} AND (cu.removed IS NOT 1 AND cu.removed IS NOT TRUE) AND (d.deleted_flag IS NULL OR d.deleted_flag != 1)`;
+        const present = this._replyWalkPresentExpression();
         const deletedLookup = `(SELECT cid, json_extract(edit, '$.deleted') AS deleted_flag FROM ${TABLES.COMMENT_UPDATES})`;
         for (const { placeholders, params } of this._cidChunks(parentCids, addrParams.length * 2)) {
-            const rows = this._prepareCached(`WITH RECURSIVE descendants(root, cid, level) AS (
-                    SELECT c.parentCid, c.cid, 1 FROM ${TABLES.COMMENTS} c
+            const rows = this._prepareCached(`WITH RECURSIVE descendants(root, cid, level, present) AS (
+                    SELECT c.parentCid, c.cid, 1, ${present} FROM ${TABLES.COMMENTS} c
                     INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid
                     LEFT JOIN ${deletedLookup} AS d ON c.cid = d.cid
-                    WHERE c.parentCid IN (${placeholders}) AND ${passes}
+                    WHERE c.parentCid IN (${placeholders}) AND ${addrClause}
                     UNION ALL
-                    SELECT desc_nodes.root, c.cid, desc_nodes.level + 1 FROM ${TABLES.COMMENTS} c
+                    SELECT desc_nodes.root, c.cid, desc_nodes.level + 1, ${present} FROM ${TABLES.COMMENTS} c
                     INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid
                     LEFT JOIN ${deletedLookup} AS d ON c.cid = d.cid
                     JOIN descendants desc_nodes ON c.parentCid = desc_nodes.cid
-                    WHERE ${passes}
+                    WHERE ${addrClause}
                 )
-                SELECT root, COUNT(*) AS replyCount, SUM(CASE WHEN level = 1 THEN 1 ELSE 0 END) AS childCount
+                SELECT root, SUM(present) AS replyCount, SUM(CASE WHEN level = 1 THEN present ELSE 0 END) AS childCount
                 FROM descendants GROUP BY root`).all(...params, ...addrParams, ...addrParams);
             for (const row of rows)
                 result.set(row.root, { replyCount: row.replyCount, childCount: row.childCount });
         }
         return result;
     }
-    // lastReplyTimestamp of every parent: the newest timestamp under it. A direct reply counts unless it is pending or
-    // disapproved (a reply with no CommentUpdate yet counts); a deeper one also needs a CommentUpdate, this
-    // community's address and to be neither removed nor deleted, and so does every comment on its path.
+    // lastReplyTimestamp of every parent: the newest timestamp among the replies replyCount counts, with the walk further
+    // narrowed to comments that are not pending. A removed, deleted or disapproved reply does not bump its thread (#403),
+    // but the present replies under it do (#405).
     _queryLastReplyTimestampsByParentCids(parentCids) {
         const result = new Map();
         const { clause: addrClause, params: addrParams } = this._communityAddressClause("c");
-        for (const { placeholders, params } of this._cidChunks(parentCids, addrParams.length)) {
-            const rows = this._prepareCached(`WITH RECURSIVE descendants(root, cid, timestamp) AS (
-                    SELECT c.parentCid, c.cid, c.timestamp FROM ${TABLES.COMMENTS} c
-                    LEFT JOIN ${TABLES.COMMENT_UPDATES} cu ON cu.cid = c.cid
-                    WHERE c.parentCid IN (${placeholders})
-                      AND COALESCE(cu.approved, 1) != 0
-                      AND (c.pendingApproval IS NULL OR c.pendingApproval != 1)
+        const walked = `${addrClause} AND (c.pendingApproval IS NULL OR c.pendingApproval != 1)`;
+        const present = this._replyWalkPresentExpression();
+        const deletedLookup = `(SELECT cid, json_extract(edit, '$.deleted') AS deleted_flag FROM ${TABLES.COMMENT_UPDATES})`;
+        for (const { placeholders, params } of this._cidChunks(parentCids, addrParams.length * 2)) {
+            const rows = this._prepareCached(`WITH RECURSIVE descendants(root, cid, timestamp, present) AS (
+                    SELECT c.parentCid, c.cid, c.timestamp, ${present} FROM ${TABLES.COMMENTS} c
+                    INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid
+                    LEFT JOIN ${deletedLookup} AS d ON c.cid = d.cid
+                    WHERE c.parentCid IN (${placeholders}) AND ${walked}
                     UNION ALL
-                    SELECT desc_nodes.root, c.cid, c.timestamp FROM ${TABLES.COMMENTS} c
+                    SELECT desc_nodes.root, c.cid, c.timestamp, ${present} FROM ${TABLES.COMMENTS} c
                     INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid
-                    LEFT JOIN (SELECT cid, json_extract(edit, '$.deleted') AS deleted_flag FROM ${TABLES.COMMENT_UPDATES}) AS d ON c.cid = d.cid
+                    LEFT JOIN ${deletedLookup} AS d ON c.cid = d.cid
                     JOIN descendants desc_nodes ON c.parentCid = desc_nodes.cid
-                    WHERE ${addrClause} AND (cu.removed IS NOT 1 AND cu.removed IS NOT TRUE) AND (d.deleted_flag IS NULL OR d.deleted_flag != 1)
-                      AND COALESCE(cu.approved, 1) != 0
-                      AND (c.pendingApproval IS NULL OR c.pendingApproval != 1)
+                    WHERE ${walked}
                 )
-                SELECT root, MAX(timestamp) AS maxTimestamp FROM descendants GROUP BY root`).all(...params, ...addrParams);
+                SELECT root, MAX(CASE WHEN present = 1 THEN timestamp END) AS maxTimestamp FROM descendants GROUP BY root`).all(...params, ...addrParams, ...addrParams);
             for (const row of rows)
                 if (row.maxTimestamp !== null)
                     result.set(row.root, row.maxTimestamp);
         }
         return result;
     }
-    // lastChildCid of every parent: its newest direct reply that has a CommentUpdate and is not pending, disapproved,
-    // removed or deleted (MAX(rowid) with the bare cid column: SQLite returns the cid of that row).
+    // lastChildCid of every parent: its newest direct reply that has a CommentUpdate and this community's address and is
+    // not pending, disapproved, removed or deleted (MAX(rowid) with the bare cid column: SQLite returns the cid of that row).
     _queryLastChildCidsByParentCids(parentCids) {
         const result = new Map();
-        for (const { placeholders, params } of this._cidChunks(parentCids)) {
+        const { clause: addrClause, params: addrParams } = this._communityAddressClause("c");
+        for (const { placeholders, params } of this._cidChunks(parentCids, addrParams.length)) {
             const rows = this._prepareCached(`SELECT c.parentCid AS parentCid, c.cid AS cid, MAX(c.rowid) AS lastRowid FROM ${TABLES.COMMENTS} c
                  INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON cu.cid = c.cid
                  LEFT JOIN (
                      SELECT cid, json_extract(edit, '$.deleted') AS deleted_flag FROM ${TABLES.COMMENT_UPDATES}
                  ) deleted_lookup ON deleted_lookup.cid = c.cid
                  WHERE c.parentCid IN (${placeholders})
+                   AND ${addrClause}
                    AND (c.pendingApproval IS NULL OR c.pendingApproval != 1)
                    AND COALESCE(cu.approved, 1) != 0
                    AND (cu.removed IS NOT 1 AND cu.removed IS NOT TRUE)
                    AND (deleted_lookup.deleted_flag IS NULL OR deleted_lookup.deleted_flag != 1)
-                 GROUP BY c.parentCid`).all(...params);
+                 GROUP BY c.parentCid`).all(...params, ...addrParams);
             for (const row of rows)
                 result.set(row.parentCid, row.cid);
         }