convex-polls 0.1.0

package/src/component/votes.ts

@@ -0,0 +1,153 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+export const castVote = mutation({
+  args: {
+    pollId: v.id("polls"),
+    optionId: v.string(),
+    voterId: v.string(),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    if (!args.voterId.trim()) {
+      throw new Error("Voter ID is required.");
+    }
+
+    const poll = await ctx.db.get(args.pollId);
+    if (!poll) {
+      throw new Error("Poll not found. The poll may have been deleted.");
+    }
+
+    if (poll.status === "closed") {
+      throw new Error("This poll is closed and no longer accepting votes.");
+    }
+
+    if (poll.config.closesAt && Date.now() > poll.config.closesAt) {
+      await ctx.db.patch(args.pollId, {
+        status: "closed",
+        closedAt: poll.config.closesAt,
+      });
+      throw new Error(
+        "This poll has expired and is no longer accepting votes.",
+      );
+    }
+
+    const validOptionIds = poll.options.map((o) => o.id);
+    if (!validOptionIds.includes(args.optionId)) {
+      throw new Error(
+        "This option doesn't exist on this poll. It may have been removed.",
+      );
+    }
+
+    const existingVotes = await ctx.db
+      .query("votes")
+      .withIndex("by_poll_voter", (q) =>
+        q.eq("pollId", args.pollId).eq("voterId", args.voterId),
+      )
+      .collect();
+
+    if (!poll.config.allowMultipleVotes && !poll.config.allowChangeVote) {
+      if (existingVotes.length > 0) {
+        throw new Error(
+          "You have already voted on this poll. This poll does not allow changing or adding votes.",
+        );
+      }
+    }
+
+    if (!poll.config.allowMultipleVotes && poll.config.allowChangeVote) {
+      for (const oldVote of existingVotes) {
+        await ctx.db.delete(oldVote._id);
+      }
+    }
+
+    if (poll.config.allowMultipleVotes) {
+      const alreadyVotedForOption = existingVotes.some(
+        (v) => v.optionId === args.optionId,
+      );
+      if (alreadyVotedForOption) {
+        throw new Error("You have already voted for this option.");
+      }
+
+      const maxVotes =
+        poll.config.maxVotesPerUser ?? poll.options.length;
+      if (existingVotes.length >= maxVotes) {
+        throw new Error(
+          `You can only vote for up to ${maxVotes} option${maxVotes === 1 ? "" : "s"} on this poll.`,
+        );
+      }
+    }
+
+    await ctx.db.insert("votes", {
+      pollId: args.pollId,
+      optionId: args.optionId,
+      voterId: args.voterId,
+      votedAt: Date.now(),
+    });
+
+    return null;
+  },
+});
+
+export const removeVote = mutation({
+  args: {
+    pollId: v.id("polls"),
+    optionId: v.string(),
+    voterId: v.string(),
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    if (!args.voterId.trim()) {
+      throw new Error("Voter ID is required.");
+    }
+
+    const poll = await ctx.db.get(args.pollId);
+    if (!poll) {
+      throw new Error("Poll not found. The poll may have been deleted.");
+    }
+
+    if (poll.status === "closed") {
+      throw new Error("Cannot remove votes from a closed poll.");
+    }
+
+    if (poll.config.closesAt && Date.now() > poll.config.closesAt) {
+      await ctx.db.patch(args.pollId, {
+        status: "closed",
+        closedAt: poll.config.closesAt,
+      });
+      throw new Error("This poll has expired. Votes can no longer be changed.");
+    }
+
+    const votes = await ctx.db
+      .query("votes")
+      .withIndex("by_poll_voter", (q) =>
+        q.eq("pollId", args.pollId).eq("voterId", args.voterId),
+      )
+      .collect();
+
+    const voteToRemove = votes.find((v) => v.optionId === args.optionId);
+    if (!voteToRemove) {
+      throw new Error("No vote found for this option.");
+    }
+
+    await ctx.db.delete(voteToRemove._id);
+    return null;
+  },
+});
+
+export const getUserVotes = query({
+  args: {
+    pollId: v.id("polls"),
+    voterId: v.string(),
+  },
+  returns: v.array(v.string()),
+  handler: async (ctx, args) => {
+    const votes = await ctx.db
+      .query("votes")
+      .withIndex("by_poll_voter", (q) =>
+        q.eq("pollId", args.pollId).eq("voterId", args.voterId),
+      )
+      .collect();
+
+    return votes.map((v) => v.optionId);
+  },
+});

package/src/react/index.ts

@@ -0,0 +1,85 @@
+"use client";
+
+import { useQuery, useMutation } from "convex/react";
+import type { FunctionReference } from "convex/server";
+import type {
+  PollWithResults,
+  PollListItem,
+} from "../client/index.js";
+
+// --- API type for hooks ---
+
+export interface PollApi {
+  get: FunctionReference<"query", "public">;
+  list: FunctionReference<"query", "public">;
+  castVote: FunctionReference<"mutation", "public">;
+  removeVote: FunctionReference<"mutation", "public">;
+  getUserVotes: FunctionReference<"query", "public">;
+}
+
+// --- usePoll hook ---
+
+export function usePoll(
+  api: PollApi,
+  pollId: string,
+  voterId?: string,
+): {
+  poll: PollWithResults | null | undefined;
+  isLoading: boolean;
+  vote: (optionId: string) => Promise<null>;
+  removeVote: (optionId: string) => Promise<null>;
+  hasVoted: boolean;
+  userVotes: string[];
+} {
+  const poll = useQuery(api.get, { pollId, voterId }) as
+    | PollWithResults
+    | null
+    | undefined;
+  const castVoteMutation = useMutation(api.castVote);
+  const removeVoteMutation = useMutation(api.removeVote);
+
+  return {
+    poll,
+    isLoading: poll === undefined,
+    vote: (optionId: string) =>
+      castVoteMutation({
+        pollId,
+        optionId,
+        voterId: voterId!,
+      }) as Promise<null>,
+    removeVote: (optionId: string) =>
+      removeVoteMutation({
+        pollId,
+        optionId,
+        voterId: voterId!,
+      }) as Promise<null>,
+    hasVoted: (poll?.userVotes?.length ?? 0) > 0,
+    userVotes: poll?.userVotes ?? [],
+  };
+}
+
+// --- usePollList hook ---
+
+export function usePollList(
+  api: Pick<PollApi, "list">,
+  args?: {
+    status?: "active" | "closed" | "scheduled";
+    createdBy?: string;
+    limit?: number;
+  },
+): {
+  polls: PollListItem[];
+  isLoading: boolean;
+} {
+  const polls = useQuery(api.list, args ?? {}) as
+    | PollListItem[]
+    | undefined;
+
+  return {
+    polls: polls ?? [],
+    isLoading: polls === undefined,
+  };
+}
+
+// Re-export types for convenience
+export type { PollWithResults, PollListItem } from "../client/index.js";

package/src/test.ts

@@ -0,0 +1,18 @@
+/// <reference types="vite/client" />
+import type { TestConvex } from "convex-test";
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import schema from "./component/schema.js";
+const modules = import.meta.glob("./component/**/*.ts");
+
+/**
+ * Register the component with the test convex instance.
+ * @param t - The test convex instance, e.g. from calling `convexTest`.
+ * @param name - The name of the component, as registered in convex.config.ts.
+ */
+export function register(
+  t: TestConvex<SchemaDefinition<GenericSchema, boolean>>,
+  name: string = "convexPolls",
+) {
+  t.registerComponent(name, schema, modules);
+}
+export default { register, schema, modules };