Plugin Architecture

1
// In schema.ts — add near other feature tables
2
export const poll = pgTable('poll', {
3
  id: uuid('id').primaryKey().defaultRandom(),
4
  networkId: uuid('network_id').references(() => network.id, { onDelete: 'cascade' }),
5
  postId: uuid('post_id').references(() => post.id, { onDelete: 'cascade' }),
6
  question: text('question').notNull(),
7
  options: text('options').array().notNull(), // JSON array of option strings
8
  expiresAt: timestamp('expires_at'),
9
  createdAt: timestamp('created_at').notNull().defaultNow(),
10
});
11
12
export const pollVote = pgTable('poll_vote', {
13
  id: uuid('id').primaryKey().defaultRandom(),
14
  pollId: uuid('poll_id').notNull().references(() => poll.id, { onDelete: 'cascade' }),
15
  userId: uuid('user_id').notNull().references(() => user.id, { onDelete: 'cascade' }),
16
  optionIndex: integer('option_index').notNull(),
17
  createdAt: timestamp('created_at').notNull().defaultNow(),
18
});

1
// packages/server/src/features/polls/PollsService.ts
2
import { eq, and, sql } from 'drizzle-orm';
3
import { db } from '../../db/client';
4
import { poll, pollVote } from '../../db/schema';
5
6
export class PollsService {
7
  async create(data: {
8
    networkId: string;
9
    postId: string;
10
    question: string;
11
    options: string[];
12
    expiresAt?: Date;
13
  }) {
14
    const [result] = await db.insert(poll).values(data).returning();
15
    return result;
16
  }
17
18
  async vote(pollId: string, userId: string, optionIndex: number) {
19
    const [result] = await db.insert(pollVote).values({
20
      pollId,
21
      userId,
22
      optionIndex,
23
    }).returning();
24
    return result;
25
  }
26
27
  async getResults(pollId: string) {
28
    const results = await db.execute(sql`
29
      SELECT option_index, COUNT(*)::int as count
30
      FROM poll_vote
31
      WHERE poll_id = ${pollId}
32
      GROUP BY option_index
33
      ORDER BY option_index
34
    `);
35
    return results.rows;
36
  }
37
}
38
39
export const pollsService = new PollsService();

1
// packages/server/src/features/polls/polls.router.ts
2
import { z } from 'zod';
3
import { router, protectedProcedure, publicProcedure } from '../../trpc/init';
4
import { pollsService } from './PollsService';
5
import { requireFeature } from '../../trpc/middleware/features';
6
7
const pollsProtected = protectedProcedure.use(requireFeature('polls'));
8
const pollsPublic = publicProcedure.use(requireFeature('polls'));
9
10
export const pollsRouter = router({
11
  create: pollsProtected
12
    .input(z.object({
13
      postId: z.string().uuid(),
14
      question: z.string().min(1).max(500),
15
      options: z.array(z.string().min(1).max(200)).min(2).max(10),
16
      expiresAt: z.date().optional(),
17
    }))
18
    .mutation(async ({ ctx, input }) => {
19
      return pollsService.create({
20
        networkId: ctx.network.id,
21
        ...input,
22
      });
23
    }),
24
25
  vote: pollsProtected
26
    .input(z.object({
27
      pollId: z.string().uuid(),
28
      optionIndex: z.number().int().min(0),
29
    }))
30
    .mutation(async ({ ctx, input }) => {
31
      return pollsService.vote(input.pollId, ctx.user.id, input.optionIndex);
32
    }),
33
34
  results: pollsPublic
35
    .input(z.object({ pollId: z.string().uuid() }))
36
    .query(async ({ input }) => {
37
      return pollsService.getResults(input.pollId);
38
    }),
39
});

1
// packages/server/src/features/polls/index.ts
2
export { pollsRouter } from './polls.router';
3
export { pollsService, PollsService } from './PollsService';

1
import { pollsRouter } from '../../features/polls';
2
3
export const appRouter = router({
4
  // ... existing routers
5
  polls: pollsRouter,
6
});

1
// packages/server/src/features/polls/__tests__/polls.test.ts
2
import { describe, it, expect } from 'vitest';
3
import { PollsService } from '../PollsService';
4
5
describe('PollsService', () => {
6
  it('should create a poll', async () => {
7
    // Test implementation
8
  });
9
});

1
const myProcedure = protectedProcedure.use(requireFeature('polls'));

1
const items = await db.query.poll.findMany({
2
  where: eq(poll.networkId, ctx.network.id),
3
});

1
import { TRPCError } from '@trpc/server';
2
3
throw new TRPCError({
4
  code: 'NOT_FOUND',
5
  message: 'Poll not found',
6
});