@voltro/plugin-comments 0.53.0

package/dist/rpc.js

@@ -0,0 +1,161 @@
+import { CommentAccessRefused as e, CommentNotFound as t, CommentNotYours as n } from "./errors.js";
+import { Schema as r } from "effect";
+import { defineMutation as i, defineQuery as a, reactivityChannel as o } from "@voltro/protocol";
+//#region src/rpc.ts
+var s = o("comments"), c = r.Struct({
+	id: r.String,
+	threadId: r.String,
+	body: r.String,
+	authorSubjectId: r.String,
+	mentions: r.Array(r.String),
+	editedAt: r.NullOr(r.String),
+	createdAt: r.String,
+	reactions: r.Array(r.Struct({
+		emoji: r.String,
+		count: r.Number,
+		mine: r.Boolean
+	}))
+}), l = r.Struct({
+	id: r.String,
+	anchor: r.String,
+	status: r.Literal("open", "resolved"),
+	createdBy: r.String,
+	createdAt: r.String,
+	comments: r.Array(c),
+	unreadCount: r.Number
+}), u = a({
+	name: "comments.list",
+	source: s,
+	input: r.Struct({ anchor: r.String }),
+	output: r.Array(l),
+	error: e,
+	openAccess: "delegated: the executor runs the app-declared anchor access rule (viaEntity guard or scope) and is fail-closed — an undeclared rule refuses every read"
+}), d = i({
+	name: "comments.create",
+	input: r.Struct({
+		anchor: r.String,
+		body: r.String,
+		threadId: r.optional(r.String),
+		mentions: r.optional(r.Array(r.String))
+	}),
+	output: r.Struct({
+		threadId: r.String,
+		commentId: r.String
+	}),
+	error: r.Union(e, t),
+	openAccess: "delegated: the executor runs the app-declared anchor access rule before any write; the author is always the calling subject"
+}), f = i({
+	name: "comments.edit",
+	input: r.Struct({
+		commentId: r.String,
+		body: r.String
+	}),
+	output: r.Struct({ ok: r.Boolean }),
+	error: r.Union(e, t, n),
+	openAccess: "author-scoped: only the comment's own author may edit, checked in the executor on top of the anchor access rule"
+}), p = i({
+	name: "comments.resolve",
+	input: r.Struct({
+		threadId: r.String,
+		resolved: r.Boolean
+	}),
+	output: r.Struct({ ok: r.Boolean }),
+	error: r.Union(e, t),
+	openAccess: "delegated: anchor access rule in the executor — anyone who may read the anchor may resolve/reopen (the Liveblocks semantic)"
+}), m = i({
+	name: "comments.delete",
+	input: r.Struct({ commentId: r.String }),
+	output: r.Struct({ ok: r.Boolean }),
+	error: r.Union(e, t, n),
+	openAccess: "author-scoped, with a comments:moderate scope override — both checked in the executor on top of the anchor access rule"
+}), h = i({
+	name: "comments.react",
+	input: r.Struct({
+		commentId: r.String,
+		emoji: r.String
+	}),
+	output: r.Struct({ reacted: r.Boolean }),
+	error: r.Union(e, t),
+	openAccess: "delegated: anchor access rule in the executor; the toggle writes only the calling subject's own reaction row"
+}), g = i({
+	name: "comments.markRead",
+	input: r.Struct({ threadId: r.String }),
+	output: r.Struct({ ok: r.Boolean }),
+	error: t,
+	openAccess: "self-scoped write: stamps only the calling subject's own read marker for the thread"
+}), _ = a({
+	name: "comments.mentionSearch",
+	input: r.Struct({ query: r.String }),
+	output: r.Array(r.Struct({
+		subjectId: r.String,
+		label: r.String
+	})),
+	openAccess: "delegated: the app-declared mention resolver receives the CALLING subject and its default filters to the caller's tenant — cross-tenant subjects are structurally unreachable"
+}), v = [
+	{
+		tag: "comments.list",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "listDescriptor"
+		}
+	},
+	{
+		tag: "comments.create",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "createDescriptor"
+		}
+	},
+	{
+		tag: "comments.edit",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "editDescriptor"
+		}
+	},
+	{
+		tag: "comments.resolve",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "resolveDescriptor"
+		}
+	},
+	{
+		tag: "comments.delete",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "deleteDescriptor"
+		}
+	},
+	{
+		tag: "comments.react",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "reactDescriptor"
+		}
+	},
+	{
+		tag: "comments.markRead",
+		kind: "mutation",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "markReadDescriptor"
+		}
+	},
+	{
+		tag: "comments.mentionSearch",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-comments/rpc",
+			name: "mentionSearchDescriptor"
+		}
+	}
+];
+//#endregion
+export { s as commentsFeed, v as commentsRpcClientImports, d as createDescriptor, m as deleteDescriptor, f as editDescriptor, u as listDescriptor, g as markReadDescriptor, _ as mentionSearchDescriptor, h as reactDescriptor, p as resolveDescriptor };

package/dist/web.d.ts

@@ -0,0 +1,60 @@
+export declare interface CommentReactionView {
+    readonly emoji: string;
+    readonly count: number;
+    readonly mine: boolean;
+}
+
+export declare interface CommentView {
+    readonly id: string;
+    readonly threadId: string;
+    readonly body: string;
+    readonly authorSubjectId: string;
+    readonly mentions: ReadonlyArray<string>;
+    readonly editedAt: string | null;
+    readonly createdAt: string;
+    readonly reactions: ReadonlyArray<CommentReactionView>;
+}
+
+export declare interface ThreadView {
+    readonly id: string;
+    readonly anchor: string;
+    readonly status: 'open' | 'resolved';
+    readonly createdBy: string;
+    readonly createdAt: string;
+    readonly comments: ReadonlyArray<CommentView>;
+    readonly unreadCount: number;
+}
+
+/**
+ * The threads on one anchor, LIVE — `comments.list` declares the plugin's
+ * reactivity channel as its `source:`, so a second client sees a new comment
+ * without a reload; every mutation below re-runs the list for all subscribers.
+ */
+export declare const useComments: (anchor: string, apiName?: string) => UseCommentsResult;
+
+export declare interface UseCommentsResult {
+    readonly threads: ReadonlyArray<ThreadView>;
+    readonly pending: boolean;
+    /** Sum of the threads' unread counters — the badge number. */
+    readonly unreadCount: number;
+    readonly create: (body: string, opts?: {
+        threadId?: string;
+        mentions?: ReadonlyArray<string>;
+    }) => Promise<unknown>;
+    readonly edit: (commentId: string, body: string) => Promise<unknown>;
+    readonly resolve: (threadId: string, resolved?: boolean) => Promise<unknown>;
+    readonly remove: (commentId: string) => Promise<unknown>;
+    readonly react: (commentId: string, emoji: string) => Promise<unknown>;
+    readonly markRead: (threadId: string) => Promise<unknown>;
+}
+
+/** @-mention autocomplete over the app-declared, tenant-filtered directory. */
+export declare const useMentionSearch: (query: string, apiName?: string) => ReadonlyArray<{
+    subjectId: string;
+    label: string;
+}>;
+
+/** One thread by id (a projection over the same live list). */
+export declare const useThread: (anchor: string, threadId: string, apiName?: string) => ThreadView | undefined;
+
+export { }

package/dist/web.js

@@ -0,0 +1,35 @@
+import { useMutation as e, useSubscription as t } from "@voltro/client";
+//#region src/web.ts
+var n = (n, r = "app") => {
+	let { data: i, loading: a } = t(r, "comments.list", { anchor: n }), o = e(r, "comments.create"), s = e(r, "comments.edit"), c = e(r, "comments.resolve"), l = e(r, "comments.delete"), u = e(r, "comments.react"), d = e(r, "comments.markRead"), f = i ?? [];
+	return {
+		threads: f,
+		pending: a,
+		unreadCount: f.reduce((e, t) => e + t.unreadCount, 0),
+		create: (e, t) => o.mutate({
+			anchor: n,
+			body: e,
+			...t?.threadId === void 0 ? {} : { threadId: t.threadId },
+			...t?.mentions === void 0 ? {} : { mentions: t.mentions }
+		}),
+		edit: (e, t) => s.mutate({
+			commentId: e,
+			body: t
+		}),
+		resolve: (e, t = !0) => c.mutate({
+			threadId: e,
+			resolved: t
+		}),
+		remove: (e) => l.mutate({ commentId: e }),
+		react: (e, t) => u.mutate({
+			commentId: e,
+			emoji: t
+		}),
+		markRead: (e) => d.mutate({ threadId: e })
+	};
+}, r = (e, t, r = "app") => n(e, r).threads.find((e) => e.id === t), i = (e, n = "app") => {
+	let { data: r } = t(n, "comments.mentionSearch", { query: e });
+	return r ?? [];
+};
+//#endregion
+export { n as useComments, i as useMentionSearch, r as useThread };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@voltro/plugin-comments",
+  "version": "0.53.0",
+  "description": "plugin-comments package",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js",
+      "default": "./dist/errors.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.js",
+      "default": "./dist/web.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/database": "0.53.0",
+    "@voltro/protocol": "0.53.0",
+    "@voltro/plugin-notifications": "0.53.0",
+    "effect": "^3.22.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}