@pkcprotocol/pkc-js 0.0.19 → 0.0.21

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

@@ -23,7 +23,7 @@ import { TIMEFRAMES_TO_SECONDS } from "../../../pages/util.js";
 import { parseCommentEditsRow, parseCommentUpdateRow, parseCommentsTableRow, parsePrefixedComment, parseVoteRow } from "./db-row-parser.js";
 import { ZodError } from "zod";
 import { messages } from "../../../errors.js";
-import { getAuthorDomainFromWire } from "../../../publications/publication-author.js";
+import { getAuthorNameFromWire } from "../../../publications/publication-author.js";
 const TABLES = Object.freeze({
     COMMENTS: "comments",
     COMMENT_UPDATES: "commentUpdates",
@@ -332,8 +332,8 @@ export class DbHandler {
             CREATE TABLE IF NOT EXISTS ${tableName} (
                 commentCid TEXT NOT NULL PRIMARY KEY UNIQUE REFERENCES ${TABLES.COMMENTS}(cid) ON DELETE CASCADE,
                 aliasPrivateKey TEXT NOT NULL,
-                originalAuthorSignerPublicKey TEXT NOT NULL,
-                originalAuthorDomain TEXT NULLABLE, -- the original author's domain address (e.g., user.eth) if they used one
+                originalAuthorPublicKey TEXT NOT NULL,
+                originalAuthorName TEXT NULLABLE, -- the original author's name (e.g., user.eth) if they used one
                 mode TEXT NOT NULL CHECK(mode IN ('per-post', 'per-reply', 'per-author')),
                 insertedAt INTEGER NOT NULL
             )
@@ -489,7 +489,7 @@ export class DbHandler {
         const moderationsToUpdate = this._db
             .prepare(`
             SELECT cm.rowid, cm.commentCid, c.authorSignerAddress,
-                   pa.originalAuthorSignerPublicKey
+                   pa.originalAuthorPublicKey
             FROM ${TABLES.COMMENT_MODERATIONS} cm
             LEFT JOIN ${TABLES.COMMENTS} c ON cm.commentCid = c.cid
             LEFT JOIN ${TABLES.PSEUDONYMITY_ALIASES} pa ON cm.commentCid = pa.commentCid
@@ -504,9 +504,9 @@ export class DbHandler {
             for (const mod of items) {
                 let targetAddress = null;
                 // If the comment was published with pseudonymity, use the original author's address
-                if (mod.originalAuthorSignerPublicKey) {
+                if (mod.originalAuthorPublicKey) {
                     try {
-                        targetAddress = getPKCAddressFromPublicKeySync(mod.originalAuthorSignerPublicKey);
+                        targetAddress = getPKCAddressFromPublicKeySync(mod.originalAuthorPublicKey);
                     }
                     catch {
                         // If we can't derive the address from the public key, fall back to authorSignerAddress
@@ -531,7 +531,7 @@ export class DbHandler {
         const moderationsToUpdate = this._db
             .prepare(`
             SELECT cm.rowid, c.author as commentAuthor,
-                   pa.originalAuthorDomain
+                   pa.originalAuthorName
             FROM ${TABLES.COMMENT_MODERATIONS} cm
             LEFT JOIN ${TABLES.COMMENTS} c ON cm.commentCid = c.cid
             LEFT JOIN ${TABLES.PSEUDONYMITY_ALIASES} pa ON cm.commentCid = pa.commentCid
@@ -547,13 +547,13 @@ export class DbHandler {
             for (const mod of items) {
                 let targetDomain = null;
                 // If the comment was published with pseudonymity, use the original author's domain
-                if (mod.originalAuthorDomain) {
-                    targetDomain = mod.originalAuthorDomain;
+                if (mod.originalAuthorName) {
+                    targetDomain = mod.originalAuthorName;
                 }
                 else if (mod.commentAuthor) {
                     try {
                         const author = JSON.parse(mod.commentAuthor);
-                        targetDomain = getAuthorDomainFromWire(author) || null;
+                        targetDomain = getAuthorNameFromWire(author) || null;
                     }
                     catch {
                         // Ignore parse errors
@@ -622,6 +622,17 @@ export class DbHandler {
                     srcRecord.extraProps = { ...existingExtra, subplebbitAddress: addr };
                     delete srcRecord["subplebbitAddress"];
                 }
+                // Rename pseudonymityAliases columns (v38 → v39)
+                if (currentDbVersion < 39 && srcTable === TABLES.PSEUDONYMITY_ALIASES) {
+                    if (srcRecord["originalAuthorSignerPublicKey"] !== undefined) {
+                        srcRecord["originalAuthorPublicKey"] = srcRecord["originalAuthorSignerPublicKey"];
+                        delete srcRecord["originalAuthorSignerPublicKey"];
+                    }
+                    if (srcRecord["originalAuthorDomain"] !== undefined) {
+                        srcRecord["originalAuthorName"] = srcRecord["originalAuthorDomain"];
+                        delete srcRecord["originalAuthorDomain"];
+                    }
+                }
                 // Prepare record for insertion (stringify JSONs, convert booleans)
                 const processedRecord = this._processRecordsForDbBeforeInsert([srcRecord])[0];
                 // Map values including rowid (preserve the original rowid value)
@@ -857,8 +868,8 @@ export class DbHandler {
         const processedAliases = this._processRecordsForDbBeforeInsert(aliases);
         const stmt = this._db.prepare(`
             INSERT OR REPLACE INTO ${TABLES.PSEUDONYMITY_ALIASES}
-            (commentCid, aliasPrivateKey, originalAuthorSignerPublicKey, originalAuthorDomain, mode, insertedAt)
-            VALUES (@commentCid, @aliasPrivateKey, @originalAuthorSignerPublicKey, @originalAuthorDomain, @mode, @insertedAt)
+            (commentCid, aliasPrivateKey, originalAuthorPublicKey, originalAuthorName, mode, insertedAt)
+            VALUES (@commentCid, @aliasPrivateKey, @originalAuthorPublicKey, @originalAuthorName, @mode, @insertedAt)
         `);
         const insertMany = this._db.transaction((items) => {
             for (const alias of items)
@@ -1070,6 +1081,294 @@ export class DbHandler {
             return { comment, commentUpdate };
         });
     }
+    queryPageCommentsWithResolvedReplies(options) {
+        // Fetch ALL descendants by following CID-ref lists stored in the DB `replies` column.
+        // Base case: direct children of parentCid.
+        // Recursive case: follow $.best.commentCids from each node's replies JSON.
+        // Returns flat rows with tree_parent for JS tree assembly.
+        const commentUpdateCols = remeda.keys.strict(CommentUpdateSchema.shape);
+        const commentIpfsCols = [...remeda.keys.strict(CommentIpfsSchema.shape), "extraProps"];
+        // Base case uses full table names (not aliases) to match _buildPageQueryParts WHERE clauses
+        const baseCommentUpdateSelects = commentUpdateCols.map((col) => `${TABLES.COMMENT_UPDATES}.${col} AS commentUpdate_${col}`);
+        const baseCommentIpfsSelects = commentIpfsCols.map((col) => `${TABLES.COMMENTS}.${col} AS commentIpfs_${col}`);
+        // Recursive part uses aliases since it joins fresh tables
+        const recCommentUpdateSelects = commentUpdateCols.map((col) => `cu2.${col} AS commentUpdate_${col}`);
+        const recCommentIpfsSelects = commentIpfsCols.map((col) => `c2.${col} AS commentIpfs_${col}`);
+        const { whereClauses, params } = this._buildPageQueryParts(options);
+        // Build recursive filter clauses (same pattern as queryFlattenedPageReplies)
+        const recursiveFilterClauses = [];
+        if (options.excludeCommentsWithDifferentCommunityAddress) {
+            const { clause, params: addrParams } = this._communityAddressClause("c2");
+            recursiveFilterClauses.push(clause);
+            params.push(...addrParams);
+        }
+        if (options.excludeCommentPendingApproval)
+            recursiveFilterClauses.push(this._pendingApprovalClause("c2"));
+        if (options.excludeRemovedComments)
+            recursiveFilterClauses.push(this._removedClause("cu2"));
+        if (options.excludeDeletedComments)
+            recursiveFilterClauses.push(this._deletedFromLookupClause("d2"));
+        if (options.excludeCommentWithApprovedFalse)
+            recursiveFilterClauses.push(this._approvedClause("cu2"));
+        const recursiveWhereExtra = recursiveFilterClauses.length > 0 ? `AND ${recursiveFilterClauses.join(" AND ")}` : "";
+        const deletedLookupJoin = options.excludeDeletedComments
+            ? `LEFT JOIN (SELECT cid, json_extract(edit, '$.deleted') AS deleted_flag FROM ${TABLES.COMMENT_UPDATES}) AS d2 ON c2.cid = d2.cid`
+            : "";
+        const queryStr = `
+            WITH RECURSIVE reply_tree AS (
+                -- Base: direct children of the target comment
+                SELECT ${baseCommentIpfsSelects.join(", ")}, ${baseCommentUpdateSelects.join(", ")},
+                       ${TABLES.COMMENTS}.parentCid AS tree_parent
+                FROM ${TABLES.COMMENTS}
+                INNER JOIN ${TABLES.COMMENT_UPDATES} ON ${TABLES.COMMENTS}.cid = ${TABLES.COMMENT_UPDATES}.cid
+                WHERE ${whereClauses.join(" AND ")}
+
+                UNION ALL
+
+                -- Recursive: follow commentCids from each parent's replies
+                SELECT ${recCommentIpfsSelects.join(", ")}, ${recCommentUpdateSelects.join(", ")},
+                       rt.commentUpdate_cid AS tree_parent
+                FROM reply_tree rt
+                CROSS JOIN json_each(
+                    json_extract(rt.commentUpdate_replies, '$.best.commentCids')
+                ) child_ref
+                JOIN ${TABLES.COMMENTS} c2 ON c2.cid = child_ref.value
+                JOIN ${TABLES.COMMENT_UPDATES} cu2 ON c2.cid = cu2.cid
+                ${deletedLookupJoin}
+                WHERE rt.commentUpdate_replies IS NOT NULL
+                  AND json_type(rt.commentUpdate_replies, '$.best.commentCids') = 'array'
+                  ${recursiveWhereExtra}
+            )
+            SELECT * FROM reply_tree
+        `;
+        const rowsRaw = this._db.prepare(queryStr).all(...params);
+        // Group by tree_parent to reconstruct the hierarchy
+        const parsedByCid = new Map();
+        const childrenByParent = new Map();
+        for (const row of rowsRaw) {
+            const { comment, commentUpdate } = this._parsePrefixedComment(row);
+            parsedByCid.set(commentUpdate.cid, { comment, commentUpdate });
+            const parent = row.tree_parent;
+            if (!childrenByParent.has(parent))
+                childrenByParent.set(parent, []);
+            childrenByParent.get(parent).push({ comment, commentUpdate });
+        }
+        // Build a commentUpdate for wire format: strip DB replies, only add resolved replies if present
+        const buildWireCommentUpdate = (commentUpdate, resolvedReplies) => {
+            const { replies: dbReplies, ...rest } = commentUpdate;
+            if (resolvedReplies)
+                return { ...rest, replies: resolvedReplies };
+            // If no resolved inline replies but DB has allPageCids, reconstruct pageCids so clients can fetch pages
+            if (dbReplies) {
+                const dbEntries = dbReplies;
+                const pageCids = {};
+                for (const [sortName, sortEntry] of Object.entries(dbEntries)) {
+                    if (sortEntry?.allPageCids?.[0])
+                        pageCids[sortName] = sortEntry.allPageCids[0];
+                }
+                if (Object.keys(pageCids).length > 0)
+                    return { ...rest, replies: { pages: {}, pageCids } };
+            }
+            return rest;
+        };
+        // Recursively attach nested replies
+        const attachReplies = (cid) => {
+            const children = childrenByParent.get(cid);
+            if (!children?.length)
+                return undefined;
+            // Sort children by the parent's commentCids order.
+            // SQLite's recursive CTE does not guarantee row order matches json_each array order
+            // when additional JOINs are involved, so we must explicitly reorder.
+            const parent = parsedByCid.get(cid);
+            const parentDbReplies = parent?.commentUpdate?.replies;
+            const cidOrder = parentDbReplies?.best?.commentCids;
+            const orderedChildren = cidOrder
+                ? cidOrder.map((childCid) => children.find((c) => c.commentUpdate.cid === childCid)).filter(Boolean)
+                : children;
+            return {
+                pages: {
+                    best: {
+                        comments: orderedChildren.map((child) => ({
+                            comment: child.comment,
+                            commentUpdate: buildWireCommentUpdate(child.commentUpdate, attachReplies(child.commentUpdate.cid))
+                        }))
+                    }
+                }
+            };
+        };
+        // Direct children with nested replies attached
+        const directChildren = childrenByParent.get(options.parentCid) ?? [];
+        return directChildren.map((child) => ({
+            comment: child.comment,
+            commentUpdate: buildWireCommentUpdate(child.commentUpdate, attachReplies(child.commentUpdate.cid))
+        }));
+    }
+    resolveRepliesCidRefsForEntries(entries) {
+        // For entries whose replies are in CID-ref format, resolve them by fetching descendants.
+        // Collects all root CIDs from all entries, runs a single recursive query, then distributes results.
+        const commentUpdateCols = remeda.keys.strict(CommentUpdateSchema.shape);
+        const commentIpfsCols = [...remeda.keys.strict(CommentIpfsSchema.shape), "extraProps"];
+        // Gather all CIDs from CID-ref replies across all entries
+        const allCids = [];
+        for (const entry of entries) {
+            const replies = entry.commentUpdate.replies;
+            if (!replies)
+                continue;
+            for (const sortEntry of Object.values(replies)) {
+                if (sortEntry?.commentCids)
+                    allCids.push(...sortEntry.commentCids);
+            }
+        }
+        // Build lookup maps from recursive query (only if we have CIDs to resolve)
+        const parsedByCid = new Map();
+        const childrenByParent = new Map();
+        if (allCids.length > 0) {
+            // Fetch all descendant trees starting from these CIDs using a recursive CTE
+            const placeholders = allCids.map(() => "?").join(",");
+            const commentUpdateSelects = commentUpdateCols.map((col) => `cu.${col} AS commentUpdate_${col}`);
+            const commentIpfsSelects = commentIpfsCols.map((col) => `c.${col} AS commentIpfs_${col}`);
+            const recCommentUpdateSelects = commentUpdateCols.map((col) => `cu2.${col} AS commentUpdate_${col}`);
+            const recCommentIpfsSelects = commentIpfsCols.map((col) => `c2.${col} AS commentIpfs_${col}`);
+            const queryStr = `
+                WITH RECURSIVE reply_tree AS (
+                    SELECT ${commentIpfsSelects.join(", ")}, ${commentUpdateSelects.join(", ")},
+                           c.parentCid AS tree_parent
+                    FROM ${TABLES.COMMENTS} c
+                    INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid
+                    WHERE c.cid IN (${placeholders})
+
+                    UNION ALL
+
+                    SELECT ${recCommentIpfsSelects.join(", ")}, ${recCommentUpdateSelects.join(", ")},
+                           rt.commentUpdate_cid AS tree_parent
+                    FROM reply_tree rt
+                    CROSS JOIN json_each(
+                        json_extract(rt.commentUpdate_replies, '$.best.commentCids')
+                    ) child_ref
+                    JOIN ${TABLES.COMMENTS} c2 ON c2.cid = child_ref.value
+                    JOIN ${TABLES.COMMENT_UPDATES} cu2 ON c2.cid = cu2.cid
+                    WHERE rt.commentUpdate_replies IS NOT NULL
+                      AND json_type(rt.commentUpdate_replies, '$.best.commentCids') = 'array'
+                )
+                SELECT * FROM reply_tree
+            `;
+            const rowsRaw = this._db.prepare(queryStr).all(...allCids);
+            // Build lookup: cid -> parsed entry
+            for (const row of rowsRaw) {
+                const { comment, commentUpdate } = this._parsePrefixedComment(row);
+                parsedByCid.set(commentUpdate.cid, { comment, commentUpdate });
+                const parent = row.tree_parent;
+                if (!childrenByParent.has(parent))
+                    childrenByParent.set(parent, []);
+                childrenByParent.get(parent).push({ comment, commentUpdate });
+            }
+        }
+        // Build a commentUpdate for wire format: strip DB replies, attach resolved replies or reconstruct pageCids
+        const buildWireCommentUpdate = (commentUpdate, resolvedReplies) => {
+            const { replies: dbReplies, ...rest } = commentUpdate;
+            if (resolvedReplies)
+                return { ...rest, replies: resolvedReplies };
+            // If no resolved inline replies but DB has allPageCids, reconstruct pageCids so clients can fetch pages
+            if (dbReplies) {
+                const dbEntries = dbReplies;
+                const pageCids = {};
+                for (const [sortName, sortEntry] of Object.entries(dbEntries)) {
+                    if (sortEntry?.allPageCids?.[0])
+                        pageCids[sortName] = sortEntry.allPageCids[0];
+                }
+                if (Object.keys(pageCids).length > 0)
+                    return { ...rest, replies: { pages: {}, pageCids } };
+            }
+            return rest;
+        };
+        const attachReplies = (cid) => {
+            const children = childrenByParent.get(cid);
+            if (!children?.length)
+                return undefined;
+            // Sort children by the parent's commentCids order.
+            // SQLite's recursive CTE does not guarantee row order matches json_each array order
+            // when additional JOINs are involved, so we must explicitly reorder.
+            const parent = parsedByCid.get(cid);
+            const parentDbReplies = parent?.commentUpdate?.replies;
+            const cidOrder = parentDbReplies?.best?.commentCids;
+            const orderedChildren = cidOrder
+                ? cidOrder.map((childCid) => children.find((c) => c.commentUpdate.cid === childCid)).filter(Boolean)
+                : children;
+            return {
+                pages: {
+                    best: {
+                        comments: orderedChildren.map((child) => ({
+                            comment: child.comment,
+                            commentUpdate: buildWireCommentUpdate(child.commentUpdate, attachReplies(child.commentUpdate.cid))
+                        }))
+                    }
+                }
+            };
+        };
+        // Resolve each entry's CID-ref replies into full nested data
+        return entries.map((entry) => {
+            const replies = entry.commentUpdate.replies;
+            if (!replies)
+                return entry;
+            // Check if it's DB CID-ref format (has commentCids or allPageCids)
+            const isDbFormat = Object.values(replies).some((s) => s?.commentCids || s?.allPageCids);
+            if (!isDbFormat)
+                return entry;
+            // Build resolved pages and pageCids from CID refs
+            const resolvedPages = {};
+            const resolvedPageCids = {};
+            for (const [sortName, sortEntry] of Object.entries(replies)) {
+                if (sortEntry?.commentCids) {
+                    const resolvedComments = sortEntry.commentCids
+                        .map((cid) => parsedByCid.get(cid))
+                        .filter(Boolean)
+                        .map((child) => ({
+                        comment: child.comment,
+                        commentUpdate: buildWireCommentUpdate(child.commentUpdate, attachReplies(child.commentUpdate.cid))
+                    }));
+                    // Derive nextCid from allPageCids[0]; fall back to legacy nextCid field for old DB rows
+                    const nextCidForSort = sortEntry.allPageCids?.[0] ?? sortEntry.nextCid;
+                    resolvedPages[sortName] = {
+                        comments: resolvedComments,
+                        ...(nextCidForSort ? { nextCid: nextCidForSort } : {})
+                    };
+                }
+                // Derive pageCid from allPageCids[0] (first page CID for this sort)
+                if (sortEntry?.allPageCids?.[0]) {
+                    resolvedPageCids[sortName] = sortEntry.allPageCids[0];
+                }
+            }
+            const { replies: _dbReplies, ...entryCommentUpdateRest } = entry.commentUpdate;
+            return {
+                ...entry,
+                commentUpdate: {
+                    ...entryCommentUpdateRest,
+                    replies: {
+                        pages: resolvedPages,
+                        ...(Object.keys(resolvedPageCids).length > 0 ? { pageCids: resolvedPageCids } : {})
+                    }
+                }
+            };
+        });
+    }
+    queryCommentAndCommentUpdateByCids(cids, opts) {
+        if (cids.length === 0)
+            return [];
+        const placeholders = cids.map(() => "?").join(",");
+        const commentUpdateSelects = opts.commentUpdateCols.map((col) => `cu.${col} AS commentUpdate_${col}`);
+        const commentIpfsSelects = opts.commentIpfsCols.map((col) => `c.${col} AS commentIpfs_${col}`);
+        const queryStr = `
+            SELECT ${commentIpfsSelects.join(", ")}, ${commentUpdateSelects.join(", ")}
+            FROM ${TABLES.COMMENTS} c
+            INNER JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid
+            WHERE c.cid IN (${placeholders})
+        `;
+        const rows = this._db.prepare(queryStr).all(...cids);
+        return rows.map((row) => {
+            const { comment, commentUpdate } = this._parsePrefixedComment(row);
+            return { comment, commentUpdate };
+        });
+    }
     queryFlattenedPageReplies(options) {
         const commentUpdateCols = remeda.keys.strict(options.commentUpdateFieldsToExclude
             ? remeda.omit(CommentUpdateSchema.shape, options.commentUpdateFieldsToExclude)
@@ -1146,6 +1445,27 @@ export class DbHandler {
             return undefined;
         return this._parseCommentUpdatesRow(row);
     }
+    queryCommentUpdateTimestampBucketReplies(opts) {
+        const row = this._db
+            .prepare(`SELECT updatedAt, postUpdatesBucket, replies FROM ${TABLES.COMMENT_UPDATES} WHERE cid = ?`)
+            .get(opts.cid);
+        if (!row)
+            return undefined;
+        return {
+            updatedAt: row.updatedAt,
+            postUpdatesBucket: row.postUpdatesBucket ?? undefined,
+            replies: typeof row.replies === "string" ? JSON.parse(row.replies) : undefined
+        };
+    }
+    queryCommentUpdateBucketAndReplies(opts) {
+        const row = this._db.prepare(`SELECT postUpdatesBucket, replies FROM ${TABLES.COMMENT_UPDATES} WHERE cid = ?`).get(opts.cid);
+        if (!row)
+            return undefined;
+        return {
+            postUpdatesBucket: row.postUpdatesBucket ?? undefined,
+            replies: typeof row.replies === "string" ? JSON.parse(row.replies) : undefined
+        };
+    }
     hasCommentWithSignatureEncoded(signatureEncoded) {
         const row = this._db
             .prepare(`SELECT 1 FROM ${TABLES.COMMENTS}
@@ -1267,42 +1587,22 @@ export class DbHandler {
                 WHERE (parent.pendingApproval IS NULL OR parent.pendingApproval != 1)
                   AND COALESCE(lc.actual_last_child_cid, '') != COALESCE(cu_parent.lastChildCid, '')
             ),
-            replies_json AS (
-                SELECT
-                    cu_parent.cid AS parentCid,
-                    json_extract(comment_entry.value, '$.comment.cid') AS comment_child_cid,
-                    json_extract(comment_entry.value, '$.commentUpdate.cid') AS update_child_cid,
-                    json_extract(comment_entry.value, '$.commentUpdate.updatedAt') AS json_child_updated_at
+            stale_replies AS (
+                SELECT DISTINCT cu_parent.cid
                 FROM ${TABLES.COMMENT_UPDATES} cu_parent
-                INNER JOIN ${TABLES.COMMENTS} parent ON parent.cid = cu_parent.cid
-                JOIN json_each(cu_parent.replies, '$.pages') pages
-                JOIN json_each(pages.value, '$.comments') comment_entry
+                CROSS JOIN json_each(
+                    json_extract(cu_parent.replies, '$.best.commentCids')
+                ) child_ref
+                JOIN ${TABLES.COMMENT_UPDATES} cu_child ON cu_child.cid = child_ref.value
                 WHERE cu_parent.replies IS NOT NULL
-                  AND json_type(cu_parent.replies, '$.pages') = 'object'
-                  AND (parent.pendingApproval IS NULL OR parent.pendingApproval != 1)
-            ),
-            stale_replies_json AS (
-                SELECT r.parentCid AS cid
-                FROM replies_json r
-                LEFT JOIN ${TABLES.COMMENTS} existing_child ON existing_child.cid = COALESCE(r.comment_child_cid, r.update_child_cid)
-                LEFT JOIN ${TABLES.COMMENT_UPDATES} actual_child_update ON actual_child_update.cid = COALESCE(r.comment_child_cid, r.update_child_cid)
-                WHERE COALESCE(r.comment_child_cid, r.update_child_cid) IS NOT NULL
-                  AND (
-                      existing_child.cid IS NULL
-                      OR actual_child_update.cid IS NULL
-                      OR (
-                          r.json_child_updated_at IS NOT NULL
-                              AND actual_child_update.cid IS NOT NULL
-                              AND CAST(r.json_child_updated_at AS INTEGER) < actual_child_update.updatedAt
-                      )
-                  )
-                GROUP BY r.parentCid
+                  AND json_type(cu_parent.replies, '$.best.commentCids') = 'array'
+                  AND cu_child.updatedAt > cu_parent.insertedAt
             ),
             base_updates AS (
                 SELECT * FROM direct_updates
                 UNION SELECT c.* FROM ${TABLES.COMMENTS} c JOIN stale_child_counts scc ON c.cid = scc.cid
                 UNION SELECT c.* FROM ${TABLES.COMMENTS} c JOIN stale_last_child_cids slc ON c.cid = slc.cid
-                UNION SELECT c.* FROM ${TABLES.COMMENTS} c JOIN stale_replies_json srj ON c.cid = srj.cid
+                UNION SELECT c.* FROM ${TABLES.COMMENTS} c JOIN stale_replies sr ON c.cid = sr.cid
             ),
             authors_to_update AS (SELECT DISTINCT authorSignerAddress FROM base_updates),
             author_comments AS (
@@ -1411,7 +1711,7 @@ export class DbHandler {
             const aliasesQuery = `
                 SELECT DISTINCT
                     comments.authorSignerAddress AS aliasSignerAddress,
-                    alias.originalAuthorSignerPublicKey AS originalAuthorSignerPublicKey
+                    alias.originalAuthorPublicKey AS originalAuthorPublicKey
                 FROM ${TABLES.PSEUDONYMITY_ALIASES} AS alias
                 INNER JOIN ${TABLES.COMMENTS} AS comments ON comments.cid = alias.commentCid
                 WHERE comments.authorSignerAddress IN (${aliasPlaceholders})
@@ -1420,7 +1720,7 @@ export class DbHandler {
             for (const aliasRow of aliasRows) {
                 let originalAuthorAddress;
                 try {
-                    originalAuthorAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorSignerPublicKey);
+                    originalAuthorAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorPublicKey);
                 }
                 catch {
                     throw new Error(`Failed to resolve original author address for alias signer address ${aliasRow.aliasSignerAddress}`);
@@ -1521,33 +1821,33 @@ export class DbHandler {
     }
     queryPseudonymityAliasByCommentCid(commentCid) {
         const row = this._db
-            .prepare(`SELECT commentCid, aliasPrivateKey, originalAuthorSignerPublicKey, originalAuthorDomain, mode, insertedAt FROM ${TABLES.PSEUDONYMITY_ALIASES} WHERE commentCid = ?`)
+            .prepare(`SELECT commentCid, aliasPrivateKey, originalAuthorPublicKey, originalAuthorName, mode, insertedAt FROM ${TABLES.PSEUDONYMITY_ALIASES} WHERE commentCid = ?`)
             .get(commentCid);
         return row;
     }
-    queryPseudonymityAliasForPost(originalAuthorSignerPublicKey, postCid) {
+    queryPseudonymityAliasForPost(originalAuthorPublicKey, postCid) {
         const row = this._db
             .prepare(`
-            SELECT alias.commentCid, alias.aliasPrivateKey, alias.originalAuthorSignerPublicKey, alias.originalAuthorDomain, alias.mode, alias.insertedAt
+            SELECT alias.commentCid, alias.aliasPrivateKey, alias.originalAuthorPublicKey, alias.originalAuthorName, alias.mode, alias.insertedAt
             FROM ${TABLES.PSEUDONYMITY_ALIASES} AS alias
             INNER JOIN ${TABLES.COMMENTS} AS comments ON comments.cid = alias.commentCid
-            WHERE alias.mode = 'per-post' AND alias.originalAuthorSignerPublicKey = ? AND comments.postCid = ?
+            WHERE alias.mode = 'per-post' AND alias.originalAuthorPublicKey = ? AND comments.postCid = ?
             ORDER BY alias.insertedAt ASC
             LIMIT 1
         `)
-            .get(originalAuthorSignerPublicKey, postCid);
+            .get(originalAuthorPublicKey, postCid);
         return row;
     }
-    queryPseudonymityAliasForAuthor(originalAuthorSignerPublicKey) {
+    queryPseudonymityAliasForAuthor(originalAuthorPublicKey) {
         const row = this._db
             .prepare(`
-            SELECT commentCid, aliasPrivateKey, originalAuthorSignerPublicKey, originalAuthorDomain, mode, insertedAt
+            SELECT commentCid, aliasPrivateKey, originalAuthorPublicKey, originalAuthorName, mode, insertedAt
             FROM ${TABLES.PSEUDONYMITY_ALIASES}
-            WHERE mode = 'per-author' AND originalAuthorSignerPublicKey = ?
+            WHERE mode = 'per-author' AND originalAuthorPublicKey = ?
             ORDER BY insertedAt ASC
             LIMIT 1
         `)
-            .get(originalAuthorSignerPublicKey);
+            .get(originalAuthorPublicKey);
         return row;
     }
     _queryCommentAuthorAndParentWithoutParsing(cid) {
@@ -1979,13 +2279,13 @@ export class DbHandler {
         // If the provided address is the original signer, include all alias signer addresses for that author.
         const aliasRowsForOriginal = this._db
             .prepare(`
-            SELECT alias.commentCid, alias.originalAuthorSignerPublicKey
+            SELECT alias.commentCid, alias.originalAuthorPublicKey
             FROM ${TABLES.PSEUDONYMITY_ALIASES} AS alias
         `)
             .all();
         for (const aliasRow of aliasRowsForOriginal) {
             try {
-                const originalAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorSignerPublicKey);
+                const originalAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorPublicKey);
                 if (originalAddress === authorSignerAddress) {
                     const commentRow = this._db
                         .prepare(`SELECT authorSignerAddress FROM ${TABLES.COMMENTS} WHERE cid = ?`)
@@ -2001,7 +2301,7 @@ export class DbHandler {
         // If the provided address is an alias, include the original signer address for that alias.
         const aliasRowsForAliasAddress = this._db
             .prepare(`
-            SELECT alias.originalAuthorSignerPublicKey
+            SELECT alias.originalAuthorPublicKey
             FROM ${TABLES.PSEUDONYMITY_ALIASES} AS alias
             INNER JOIN ${TABLES.COMMENTS} AS comments ON comments.cid = alias.commentCid
             WHERE comments.authorSignerAddress = ?
@@ -2009,7 +2309,7 @@ export class DbHandler {
             .all(authorSignerAddress);
         for (const aliasRow of aliasRowsForAliasAddress) {
             try {
-                const originalAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorSignerPublicKey);
+                const originalAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorPublicKey);
                 authorSignerAddresses.add(originalAddress);
             }
             catch {
@@ -2073,7 +2373,7 @@ export class DbHandler {
         // Get original author's address for mod edits (bans/flairs are applied to original author)
         const modEditAddresses = [authorSignerAddress];
         try {
-            const originalAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorSignerPublicKey);
+            const originalAddress = getPKCAddressFromPublicKeySync(aliasRow.originalAuthorPublicKey);
             if (originalAddress !== authorSignerAddress) {
                 modEditAddresses.push(originalAddress);
             }
@@ -2082,7 +2382,7 @@ export class DbHandler {
             // ignore malformed keys
         }
         // For mod edits (bans/flairs), use the original author's domain if available
-        const modEditDomain = aliasRow.originalAuthorDomain || authorDomain;
+        const modEditDomain = aliasRow.originalAuthorName || authorDomain;
         // Query karma for just this alias, but mod edits from both alias and original
         return this._queryCommunityAuthorByAddresses([authorSignerAddress], modEditAddresses, modEditDomain);
     }
@@ -2140,7 +2440,7 @@ export class DbHandler {
             this._db.prepare(`DELETE FROM ${TABLES.VOTES} WHERE commentCid = ?`).run(cid);
             this._db.prepare(`DELETE FROM ${TABLES.COMMENT_EDITS} WHERE commentCid = ?`).run(cid);
             this._db.prepare(`DELETE FROM ${TABLES.PSEUDONYMITY_ALIASES} WHERE commentCid = ?`).run(cid);
-            const commentUpdate = this.queryStoredCommentUpdate({ cid });
+            const commentUpdate = this.queryCommentUpdateBucketAndReplies({ cid });
             if (commentUpdate) {
                 this._db.prepare(`DELETE FROM ${TABLES.COMMENT_UPDATES} WHERE cid = ?`).run(cid);
             }
@@ -2326,36 +2626,25 @@ export class DbHandler {
     queryAllCommentCidsAndTheirReplies() {
         const log = Logger("pkc-js:local-community:db-handler:queryAllCidsUnderThisCommunity");
         const rows = this._db
-            .prepare(`SELECT 
-                     c.cid AS cid,
-                     CASE
-                         WHEN cu.replies IS NULL THEN NULL
-                         ELSE json_set(
-                             cu.replies,
-                             '$.pages',
-                             (
-                                 SELECT json_group_object(
-                                     pages.key,
-                                     json_set(pages.value, '$.comments', json('[]'))
-                                 )
-                                 FROM json_each(cu.replies, '$.pages') AS pages
-                             )
-                         )
-                     END AS replies
+            .prepare(`SELECT c.cid AS cid, cu.replies AS replies
                  FROM ${TABLES.COMMENTS} c
                  LEFT JOIN ${TABLES.COMMENT_UPDATES} cu ON c.cid = cu.cid`)
             .all();
         return rows.map((row) => {
-            let parsedReplies;
+            const allPageCids = [];
             if (typeof row.replies === "string" && row.replies.length > 0) {
                 try {
-                    parsedReplies = JSON.parse(row.replies);
+                    const parsed = JSON.parse(row.replies);
+                    for (const sortEntry of Object.values(parsed)) {
+                        if (sortEntry?.allPageCids)
+                            allPageCids.push(...sortEntry.allPageCids);
+                    }
                 }
                 catch (e) {
                     log.error(`Failed to parse replies JSON for comment ${row.cid} when collecting cids`, e);
                 }
             }
-            return { cid: row.cid, replies: parsedReplies };
+            return { cid: row.cid, allPageCids };
         });
     }
     queryPostsWithActiveScore(pageOptions) {