@better-apps/comments 0.0.0-stage → 0.0.0

package/dist/runtime.js

@@ -0,0 +1,110 @@
+import { BetterAppsError } from "better-apps";
+import { accessTo, mentionable, nothing, orgOf, subjectOf } from "./access.js";
+import { CommentsError } from "./errors.js";
+import { threadModel } from "./schema.js";
+/**
+ * Who a call acts as. Server code that passes neither an actor nor a request is trusted, so its reads and writes skip
+ * access checks; server code acting for a request or an actor is checked as that user.
+ */
+export function callerOf(context) {
+    return {
+        actor: context.actor,
+        trusted: context.source === "api" && context.actor === null && context.request === null
+    };
+}
+/** The author of a write, or `UNAUTHENTICATED` without one. */
+export function requireAuthor(context) {
+    if (!context.author) {
+        throw new CommentsError("UNAUTHENTICATED", "Sign in to comment.");
+    }
+    return context.author;
+}
+/** The id stored for an author: a user id, or the id server code gave an external or system author. */
+export function authorIdOf(author) {
+    return author.type === "user" ? author.userId : (author.id ?? "");
+}
+/** Whether an author wrote a comment. */
+export function wrote(author, comment) {
+    return comment.authorType === author.type && comment.authorId === authorIdOf(author);
+}
+/** A thread by id, or `NOT_FOUND`. */
+export async function loadThread(context, threadId) {
+    const thread = await context.db.findOne({
+        model: threadModel,
+        where: [{ field: "id", value: threadId }]
+    });
+    if (!thread) {
+        throw new CommentsError("NOT_FOUND", "That thread doesn't exist, or you can't see it.");
+    }
+    return thread;
+}
+/**
+ * What the caller may do with a thread. A thread outside its subject's current organization can't be seen. Reads pass
+ * the request, so a grant it carries counts; writes leave it out.
+ */
+export async function threadAccess(config, context, thread, request) {
+    const rules = subjectOf(config.subjects, thread.subjectType);
+    const caller = callerOf(context);
+    const ref = { subjectType: thread.subjectType, subjectId: thread.subjectId };
+    let access = nothing;
+    if (caller.trusted || (await orgOf(context.subjects, caller, ref)) === thread.orgId) {
+        access = await accessTo(rules, context.subjects, caller, ref, thread.visibility, request);
+    }
+    return { rules, caller, access };
+}
+/** Refuses an action the caller can view but can't take. */
+export function forbid(allowed, message) {
+    if (!allowed) {
+        throw new CommentsError("FORBIDDEN", message);
+    }
+}
+/**
+ * Runs a before hook and checks what it returns with the action's schema. A `BetterAppsError`, such as a
+ * `CommentsError`, keeps its code; any other error becomes `REJECTED_BY_HOOK`.
+ */
+export async function runHook(hook, args, schema) {
+    if (!hook) {
+        return args.input;
+    }
+    let changed;
+    try {
+        changed = await hook(args);
+    }
+    catch (error) {
+        if (error instanceof BetterAppsError) {
+            throw error;
+        }
+        throw new CommentsError("REJECTED_BY_HOOK", "The change was refused.", { cause: error });
+    }
+    const result = await schema["~standard"].validate(changed);
+    if (result.issues) {
+        throw new CommentsError("INVALID_INPUT", "The input a hook returned isn't valid.", { issues: result.issues });
+    }
+    return result.value;
+}
+/** Splits ids into lists of at most 90, under D1's limit of 100 bound parameters. */
+export function chunks(items, size = 90) {
+    const lists = [];
+    for (let start = 0; start < items.length; start += size) {
+        lists.push(items.slice(start, start + size));
+    }
+    return lists;
+}
+/** Looks up users' names and avatars, keyed by id. Users the identity adapter can't find are left out. */
+export async function lookupUsers(context, ids) {
+    const unique = [...new Set(ids)].filter((id) => id !== "");
+    const { getUsers } = context.identity;
+    if (!getUsers || unique.length === 0) {
+        return {};
+    }
+    const found = await Promise.all(chunks(unique).map(async (list) => getUsers.call(context.identity, list)));
+    return Object.fromEntries(found.flat().map((user) => [user.id, user]));
+}
+/** Where a thread's mentions are checked: its organization, and who may be mentioned there. */
+export function mentionScope(config, context, thread) {
+    return {
+        identity: context.identity,
+        orgId: thread.orgId === "" ? null : thread.orgId,
+        allowed: async (actors) => mentionable(config.subjects, context.subjects, actors, thread)
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,62 @@
+import type { FeatureSchema, FieldAttribute } from "better-apps";
+/** Typed columns an app adds to threads or comments. The CLI generates them with the rest of the schema. */
+export interface AdditionalFields {
+    thread?: Readonly<Record<string, FieldAttribute>> | undefined;
+    comment?: Readonly<Record<string, FieldAttribute>> | undefined;
+}
+type FieldValueOf<Field extends FieldAttribute> = Field["type"] extends "string" ? string : Field["type"] extends "number" ? number : Field["type"] extends "boolean" ? boolean : Field["type"] extends "date" ? Date : Field["type"] extends "string[]" ? string[] : Field["type"] extends "number[]" ? number[] : Field["type"] extends readonly (infer Value extends string)[] ? Value : unknown;
+/** The values of additional fields as rows hold them. Optional fields may be `null`. */
+export type InferFields<Fields> = {
+    -readonly [Name in keyof Fields]: Fields[Name] extends FieldAttribute ? Fields[Name]["required"] extends false ? FieldValueOf<Fields[Name]> | null : FieldValueOf<Fields[Name]> : never;
+};
+/** One conversation at one place in a subject. */
+export type CommentThread = {
+    id: string;
+    /** The organization that owns the subject, or `""` when the app has none. */
+    orgId: string;
+    subjectType: string;
+    subjectId: string;
+    /** `default`, or a visibility the subject type declares, such as `staff`. */
+    visibility: string;
+    /** `null` means the whole subject. */
+    anchorKind: string | null;
+    anchor: unknown;
+    /** The content version the anchor was made against, such as a deploy, commit or document revision. */
+    anchorVersion: string | null;
+    status: "open" | "resolved";
+    resolvedAt: Date | null;
+    resolvedBy: string | null;
+    createdBy: string;
+    createdAt: Date;
+    /** When the newest comment was written, deleted or not. */
+    lastActivityAt: Date;
+    /** Comments that aren't deleted. */
+    commentCount: number;
+    metadata: Record<string, unknown> | null;
+};
+/** One message in a thread. */
+export type Comment = {
+    id: string;
+    threadId: string;
+    orgId: string;
+    /** `user`, `external` for people without an account, or `system` for bots. */
+    authorType: "user" | "external" | "system";
+    /** A user id, or the id server code gave an external or system author (`""` without one). */
+    authorId: string;
+    /** Stored only for external and system authors, who the identity adapter can't look up. */
+    authorName: string | null;
+    format: string;
+    /** `null` once the comment is deleted, or its author removed. */
+    body: unknown;
+    /** Plain text from the format, with mentions as tokens. Empty once deleted. */
+    bodyText: string;
+    createdAt: Date;
+    editedAt: Date | null;
+    deletedAt: Date | null;
+    metadata: Record<string, unknown> | null;
+};
+export declare const threadModel = "commentThread";
+export declare const commentModel = "comment";
+/** The comments tables, with the app's additional fields. */
+export declare function commentsSchema(additional?: AdditionalFields): FeatureSchema;
+export {};

package/dist/schema.js

@@ -0,0 +1,53 @@
+export const threadModel = "commentThread";
+export const commentModel = "comment";
+/** The comments tables, with the app's additional fields. */
+export function commentsSchema(additional = {}) {
+    return {
+        [threadModel]: {
+            fields: {
+                orgId: { type: "string", defaultValue: "" },
+                subjectType: { type: "string" },
+                subjectId: { type: "string" },
+                visibility: { type: "string", defaultValue: "default" },
+                anchorKind: { type: "string", required: false },
+                anchor: { type: "json", required: false },
+                anchorVersion: { type: "string", required: false },
+                status: { type: ["open", "resolved"], defaultValue: "open" },
+                resolvedAt: { type: "date", required: false },
+                resolvedBy: { type: "string", required: false },
+                createdBy: { type: "string" },
+                createdAt: { type: "date" },
+                lastActivityAt: { type: "date" },
+                commentCount: { type: "number", defaultValue: 0 },
+                metadata: { type: "json", required: false },
+                ...additional.thread
+            },
+            // Better Auth's schema format indexes declared fields only, so ties on time are broken by the id outside the index.
+            indexes: [
+                { fields: ["orgId", "subjectType", "subjectId", "lastActivityAt"], name: "comment_thread_by_activity" },
+                { fields: ["orgId", "subjectType", "subjectId", "createdAt"], name: "comment_thread_by_creation" }
+            ]
+        },
+        [commentModel]: {
+            fields: {
+                threadId: { type: "string", references: { model: threadModel, field: "id", onDelete: "cascade" } },
+                orgId: { type: "string", defaultValue: "" },
+                authorType: { type: ["user", "external", "system"] },
+                authorId: { type: "string" },
+                authorName: { type: "string", required: false },
+                format: { type: "string", defaultValue: "text" },
+                body: { type: "json", required: false },
+                bodyText: { type: "string", defaultValue: "" },
+                createdAt: { type: "date" },
+                editedAt: { type: "date", required: false },
+                deletedAt: { type: "date", required: false },
+                metadata: { type: "json", required: false },
+                ...additional.comment
+            },
+            indexes: [
+                { fields: ["threadId", "createdAt"], name: "comment_by_thread" },
+                { fields: ["authorType", "authorId"], name: "comment_by_author" }
+            ]
+        }
+    };
+}

package/dist/subjects.d.ts

@@ -0,0 +1,17 @@
+import type { SubjectDefinition, SubjectGrants } from "better-apps";
+import { type Config } from "./runtime.js";
+/**
+ * The subject types comments declare for their own records, so other features, such as reactions, can attach to a
+ * thread or a comment. Whoever can see a thread can see it and its comments.
+ */
+export declare const commentSubjectTypes: {
+    readonly thread: "comments.thread";
+    readonly comment: "comments.comment";
+};
+/** The subject types for comments' own records, with access following each thread's. */
+export declare function commentSubjects(config: Config): Record<string, SubjectDefinition>;
+/**
+ * Lets a request see a thread and its comments, such as their reactions, when a grant it carries, such as a share link,
+ * lets it see the thread's subject. Like reads, it reaches only default threads in their subject's current organization.
+ */
+export declare function commentGrants(config: Config): SubjectGrants;

package/dist/subjects.js

@@ -0,0 +1,93 @@
+import { canViewThreads, viewThreads } from "./access.js";
+import { chunks } from "./runtime.js";
+import { commentModel, threadModel } from "./schema.js";
+/**
+ * The subject types comments declare for their own records, so other features, such as reactions, can attach to a
+ * thread or a comment. Whoever can see a thread can see it and its comments.
+ */
+export const commentSubjectTypes = { thread: "comments.thread", comment: "comments.comment" };
+async function findRows(db, model, ids) {
+    const lists = chunks([...new Set(ids)]);
+    const rows = await Promise.all(lists.map(async (list) => db.findMany({ model, where: [{ field: "id", operator: "in", value: list }] })));
+    return new Map(rows.flat().map((row) => [row.id, row]));
+}
+const threadsById = async (db, ids) => findRows(db, threadModel, ids);
+// A comment's thread, keyed by the comment's id. A deleted comment has none, so nothing attaches to it any more.
+const threadsOfComments = async (db, ids) => {
+    const comments = await findRows(db, commentModel, ids);
+    const threads = await threadsById(db, [...comments.values()].map((comment) => comment.threadId));
+    const found = new Map();
+    for (const [id, comment] of comments) {
+        const thread = threads.get(comment.threadId);
+        if (thread && !comment.deletedAt) {
+            found.set(id, thread);
+        }
+    }
+    return found;
+};
+function subjectOfThreads(config, find) {
+    const viewable = async (checks, context) => {
+        const threads = await find(context.db, checks.map((check) => check.subjectId));
+        const pairs = checks.flatMap(({ actor, subjectId }, index) => {
+            const thread = threads.get(subjectId);
+            return thread ? [{ index, actor, thread }] : [];
+        });
+        const allowed = await canViewThreads(config.subjects, context.subjects, pairs);
+        const result = checks.map(() => false);
+        for (const [position, { index }] of pairs.entries()) {
+            result[index] = allowed[position] === true;
+        }
+        return result;
+    };
+    const orgIds = async (refs, context) => {
+        const threads = await find(context.db, refs.map((ref) => ref.subjectId));
+        return refs.map((ref) => threads.get(ref.subjectId)?.orgId || null);
+    };
+    return {
+        canView: async (args, context) => (await viewable([args], context))[0] === true,
+        canViewMany: viewable,
+        getOrgId: async (ref, context) => (await orgIds([ref], context))[0] ?? null,
+        getOrgIds: orgIds,
+        publicRead: async ({ subjectId }, context) => (await viewable([{ actor: null, subjectId }], context))[0] === true,
+        publicReadMany: async (refs, context) => viewable(refs.map(({ subjectId }) => ({ actor: null, subjectId })), context)
+    };
+}
+/** The subject types for comments' own records, with access following each thread's. */
+export function commentSubjects(config) {
+    return {
+        [commentSubjectTypes.thread]: subjectOfThreads(config, threadsById),
+        [commentSubjectTypes.comment]: subjectOfThreads(config, threadsOfComments)
+    };
+}
+/**
+ * Lets a request see a thread and its comments, such as their reactions, when a grant it carries, such as a share link,
+ * lets it see the thread's subject. Like reads, it reaches only default threads in their subject's current organization.
+ */
+export function commentGrants(config) {
+    const finders = {
+        [commentSubjectTypes.thread]: threadsById,
+        [commentSubjectTypes.comment]: threadsOfComments
+    };
+    return {
+        async canViewMany(checks, _args, context) {
+            const answers = checks.map(() => false);
+            await Promise.all(Object.entries(finders).map(async ([subjectType, find]) => {
+                const indexes = checks.flatMap((check, index) => (check.subjectType === subjectType ? [index] : []));
+                if (indexes.length === 0) {
+                    return;
+                }
+                const threads = await find(context.db, indexes.map((index) => checks[index]?.subjectId ?? ""));
+                const pairs = indexes.flatMap((index) => {
+                    const check = checks[index];
+                    const thread = threads.get(check?.subjectId ?? "");
+                    return check && thread ? [{ index, actor: null, thread, request: check.request }] : [];
+                });
+                const views = await viewThreads(config.subjects, context.subjects, pairs);
+                for (const [position, { index }] of pairs.entries()) {
+                    answers[index] = views[position] !== null;
+                }
+            }));
+            return answers;
+        }
+    };
+}

package/dist/ulid.d.ts

@@ -0,0 +1,4 @@
+/** Makes a ULID, such as the id of a comment a client is about to write. */
+export declare function ulid(time?: number): string;
+/** Whether a value is a ULID in canonical upper case. */
+export declare function isUlid(value: unknown): value is string;

package/dist/ulid.js

@@ -0,0 +1,24 @@
+// ULIDs: 48 bits of time and 80 random bits in Crockford's base 32, so ids sort roughly by creation and a client can
+// make one before the server sees the write.
+const alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const pattern = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
+/** Makes a ULID, such as the id of a comment a client is about to write. */
+export function ulid(time = Date.now()) {
+    let timePart = "";
+    let rest = Math.floor(time);
+    for (let index = 0; index < 10; index += 1) {
+        timePart = alphabet[rest % 32] + timePart;
+        rest = Math.floor(rest / 32);
+    }
+    // 256 is a multiple of 32, so each byte maps to a character without bias.
+    const random = crypto.getRandomValues(new Uint8Array(16));
+    let randomPart = "";
+    for (const byte of random) {
+        randomPart += alphabet[byte % 32];
+    }
+    return timePart + randomPart;
+}
+/** Whether a value is a ULID in canonical upper case. */
+export function isUlid(value) {
+    return typeof value === "string" && pattern.test(value);
+}

package/dist/upkeep.d.ts

@@ -0,0 +1,27 @@
+import type { Config, Context } from "./runtime.js";
+/** The result of one step of upkeep. */
+export interface UpkeepStep {
+    done: boolean;
+}
+/**
+ * Deletes up to 50 of a removed record's threads, emitting `thread.deleted` for each. The last step emits
+ * `subject.removed`.
+ */
+export declare function removeSubject(config: Config, context: Context): Promise<UpkeepStep>;
+/**
+ * Moves up to 50 of a record's threads, and their comments, to another organization, emitting `thread.moved` for each.
+ * The last step emits `subject.moved`.
+ */
+export declare function moveSubject(config: Config, context: Context): Promise<UpkeepStep>;
+/**
+ * Clears the bodies of up to 90 of a removed user's comments. The comments stay, so threads keep their shape, and show
+ * as removed text from a former user. The last step emits `user.removed`.
+ */
+export declare function removeUser(_config: Config, context: Context): Promise<UpkeepStep>;
+/**
+ * Recomputes `commentCount` and `lastActivityAt` for up to 50 threads, to repair data changed outside comments, such
+ * as by a hand-written migration. Pass thread ids, or a subject and the cursor from the previous step.
+ */
+export declare function recountThreads(config: Config, context: Context): Promise<UpkeepStep & {
+    cursor: string | null;
+}>;

package/dist/upkeep.js

@@ -0,0 +1,189 @@
+import { subjectOf } from "./access.js";
+import { limits } from "./content.js";
+import { commentModel, threadModel } from "./schema.js";
+const step = limits.maxThreadsPerPage;
+const usersStep = 90;
+async function subjectThreads(context, subjectType, subjectId, orgIdNot) {
+    const threads = await context.db.findMany({
+        model: threadModel,
+        where: [
+            { field: "subjectType", value: subjectType },
+            { field: "subjectId", value: subjectId },
+            ...(orgIdNot === undefined ? [] : [{ field: "orgId", operator: "ne", value: orgIdNot }])
+        ],
+        sortBy: { field: "id", direction: "asc" },
+        limit: step
+    });
+    const comments = threads.length === 0
+        ? []
+        : await context.db.findMany({
+            model: commentModel,
+            where: [{ field: "threadId", operator: "in", value: threads.map((thread) => thread.id) }],
+            select: ["id", "threadId"]
+        });
+    const commentIds = (thread) => comments.filter((comment) => comment.threadId === thread.id).map((comment) => comment.id);
+    return { threads, ids: threads.map((thread) => thread.id), commentIds };
+}
+const eventData = (thread) => ({
+    subjectType: thread.subjectType,
+    subjectId: thread.subjectId,
+    orgId: thread.orgId,
+    thread
+});
+/**
+ * Deletes up to 50 of a removed record's threads, emitting `thread.deleted` for each. The last step emits
+ * `subject.removed`.
+ */
+export async function removeSubject(config, context) {
+    const { subjectType, subjectId } = context.input;
+    subjectOf(config.subjects, subjectType);
+    const { threads, ids, commentIds } = await subjectThreads(context, subjectType, subjectId);
+    const done = ids.length < step;
+    for (const thread of threads) {
+        context.emit("thread.deleted", { ...eventData(thread), commentIds: commentIds(thread) });
+    }
+    if (done) {
+        context.emit("subject.removed", { subjectType, subjectId });
+    }
+    if (ids.length > 0) {
+        await context.db.batch([
+            { type: "deleteMany", model: commentModel, where: [{ field: "threadId", operator: "in", value: ids }] },
+            { type: "deleteMany", model: threadModel, where: [{ field: "id", operator: "in", value: ids }] }
+        ]);
+    }
+    return { done };
+}
+/**
+ * Moves up to 50 of a record's threads, and their comments, to another organization, emitting `thread.moved` for each.
+ * The last step emits `subject.moved`.
+ */
+export async function moveSubject(config, context) {
+    const input = context.input;
+    const { subjectType, subjectId } = input;
+    subjectOf(config.subjects, subjectType);
+    const toOrgId = input.toOrgId ?? "";
+    const { threads, ids, commentIds } = await subjectThreads(context, subjectType, subjectId, toOrgId);
+    const done = ids.length < step;
+    for (const thread of threads) {
+        context.emit("thread.moved", {
+            ...eventData({ ...thread, orgId: toOrgId }),
+            fromOrgId: thread.orgId,
+            commentIds: commentIds(thread)
+        });
+    }
+    if (done) {
+        context.emit("subject.moved", { subjectType, subjectId, toOrgId });
+    }
+    if (ids.length > 0) {
+        await context.db.batch([
+            {
+                type: "updateMany",
+                model: commentModel,
+                where: [{ field: "threadId", operator: "in", value: ids }],
+                update: { orgId: toOrgId }
+            },
+            {
+                type: "updateMany",
+                model: threadModel,
+                where: [{ field: "id", operator: "in", value: ids }],
+                update: { orgId: toOrgId }
+            }
+        ]);
+    }
+    return { done };
+}
+/**
+ * Clears the bodies of up to 90 of a removed user's comments. The comments stay, so threads keep their shape, and show
+ * as removed text from a former user. The last step emits `user.removed`.
+ */
+export async function removeUser(_config, context) {
+    const { userId } = context.input;
+    const comments = await context.db.findMany({
+        model: commentModel,
+        where: [
+            { field: "authorType", value: "user" },
+            { field: "authorId", value: userId },
+            { field: "body", operator: "ne", value: null }
+        ],
+        sortBy: { field: "id", direction: "asc" },
+        limit: usersStep,
+        select: ["id"]
+    });
+    const ids = comments.map((comment) => comment.id);
+    const done = ids.length < usersStep;
+    if (done) {
+        context.emit("user.removed", { userId });
+    }
+    if (ids.length > 0) {
+        await context.db.batch([
+            {
+                type: "updateMany",
+                model: commentModel,
+                where: [{ field: "id", operator: "in", value: ids }],
+                update: { body: null, bodyText: "" }
+            }
+        ]);
+    }
+    return { done };
+}
+/**
+ * Recomputes `commentCount` and `lastActivityAt` for up to 50 threads, to repair data changed outside comments, such
+ * as by a hand-written migration. Pass thread ids, or a subject and the cursor from the previous step.
+ */
+export async function recountThreads(config, context) {
+    const input = context.input;
+    let ids;
+    let cursor = null;
+    if (input.threadIds) {
+        ids = [...new Set(input.threadIds)];
+    }
+    else {
+        const subjectType = input.subjectType;
+        subjectOf(config.subjects, subjectType);
+        const threads = await context.db.findMany({
+            model: threadModel,
+            where: [
+                { field: "subjectType", value: subjectType },
+                { field: "subjectId", value: input.subjectId },
+                ...(input.cursor === undefined ? [] : [{ field: "id", operator: "gt", value: input.cursor }])
+            ],
+            sortBy: { field: "id", direction: "asc" },
+            limit: step,
+            select: ["id"]
+        });
+        ids = threads.map((thread) => thread.id);
+        cursor = ids.length === step ? (ids.at(-1) ?? null) : null;
+    }
+    if (ids.length === 0) {
+        return { done: true, cursor: null };
+    }
+    const [counts, latest] = await Promise.all([
+        context.db.countGroups({
+            model: commentModel,
+            where: [
+                { field: "threadId", operator: "in", value: ids },
+                { field: "deletedAt", value: null }
+            ],
+            groupBy: ["threadId"]
+        }),
+        Promise.all(ids.map(async (threadId) => {
+            const [newest] = await context.db.findMany({
+                model: commentModel,
+                where: [{ field: "threadId", value: threadId }],
+                sortBy: { field: "createdAt", direction: "desc" },
+                limit: 1,
+                select: ["createdAt"]
+            });
+            return [threadId, newest?.createdAt];
+        }))
+    ]);
+    const countOf = new Map(counts.map(({ group, count }) => [String(group.threadId), count]));
+    const operations = latest.map(([threadId, newest]) => ({
+        type: "update",
+        model: threadModel,
+        where: [{ field: "id", value: threadId }],
+        update: { commentCount: countOf.get(threadId) ?? 0, ...(newest ? { lastActivityAt: newest } : {}) }
+    }));
+    await context.db.batch(operations);
+    return { done: cursor === null, cursor };
+}

package/dist/writes.d.ts

@@ -0,0 +1,27 @@
+import { type Config, type Context } from "./runtime.js";
+import { type Comment, type CommentThread } from "./schema.js";
+export declare function createThread(config: Config, context: Context): Promise<{
+    thread: CommentThread;
+    comment: Comment;
+    droppedMentions: string[];
+}>;
+export declare function reply(config: Config, context: Context): Promise<{
+    thread: CommentThread;
+    comment: Comment;
+    droppedMentions: string[];
+}>;
+export declare function editComment(config: Config, context: Context): Promise<{
+    comment: Comment;
+    droppedMentions: string[];
+}>;
+export declare function deleteComment(config: Config, context: Context): Promise<{
+    comment: Comment;
+    threadDeleted: boolean;
+}>;
+export declare const resolveThread: (config: Config, context: Context) => Promise<CommentThread>;
+export declare const reopenThread: (config: Config, context: Context) => Promise<CommentThread>;
+export declare function updateThread(config: Config, context: Context): Promise<CommentThread>;
+export declare function updateAnchor(config: Config, context: Context): Promise<CommentThread>;
+export declare function deleteThread(config: Config, context: Context): Promise<{
+    threadId: string;
+}>;