♻️ Rename registration token to invite, add created by

src/server/api/root.ts

@@ -8,6 +8,7 @@ import { dnsHoleRouter } from './routers/dns-hole';
 import { dockerRouter } from './routers/docker/router';
 import { downloadRouter } from './routers/download';
 import { iconRouter } from './routers/icon';
+import { inviteRouter } from './routers/invite';
 import { mediaRequestsRouter } from './routers/media-request';
 import { mediaServerRouter } from './routers/media-server';
 import { overseerrRouter } from './routers/overseerr';
@@ -15,7 +16,6 @@ import { rssRouter } from './routers/rss';
 import { usenetRouter } from './routers/usenet/router';
 import { userRouter } from './routers/user';
 import { weatherRouter } from './routers/weather';
-import { inviteRouter } from './routers/registrationTokens';
 
 /**
  * This is the primary router for your server.
@@ -38,7 +38,7 @@ export const rootRouter = createTRPCRouter({
   usenet: usenetRouter,
   calendar: calendarRouter,
   weather: weatherRouter,
-  registrationTokens: inviteRouter
+  invites: inviteRouter,
 });
 
 // export type definition of API

src/server/api/routers/invite.ts

@@ -2,34 +2,42 @@ import { randomBytes } from 'crypto';
 import dayjs from 'dayjs';
 import { z } from 'zod';
 
-import { createTRPCRouter, publicProcedure } from '../trpc';
+import { adminProcedure, createTRPCRouter, publicProcedure } from '../trpc';
 
 export const inviteRouter = createTRPCRouter({
-  getAllInvites: publicProcedure
+  all: adminProcedure
     .input(
       z.object({
         limit: z.number().min(1).max(100).nullish().default(10),
-        page: z.number().min(0)
+        page: z.number().min(0),
       })
     )
     .query(async ({ ctx, input }) => {
       const limit = input.limit ?? 50;
-      const registrationTokens = await ctx.prisma.registrationToken.findMany({
+      const invites = await ctx.prisma.invite.findMany({
         take: limit,
         skip: limit * input.page,
+        include: {
+          createdBy: {
+            select: {
+              name: true,
+            },
+          },
+        },
       });
 
-      const countRegistrationTokens = await ctx.prisma.registrationToken.count();
+      const inviteCount = await ctx.prisma.invite.count();
 
       return {
-        registrationTokens: registrationTokens.map((token) => ({
+        invites: invites.map((token) => ({
           id: token.id,
           expires: token.expires,
+          creator: token.createdBy.name,
         })),
-        countPages: Math.ceil(countRegistrationTokens / limit)
+        countPages: Math.ceil(inviteCount / limit),
       };
     }),
-  createRegistrationToken: publicProcedure
+  create: adminProcedure
     .input(
       z.object({
         expiration: z
@@ -39,9 +47,10 @@ export const inviteRouter = createTRPCRouter({
       })
     )
     .mutation(async ({ ctx, input }) => {
-      const token = await ctx.prisma.registrationToken.create({
+      const token = await ctx.prisma.invite.create({
         data: {
           expires: input.expiration,
+          createdById: ctx.session.user.id,
           token: randomBytes(20).toString('hex'),
         },
       });
@@ -52,10 +61,10 @@ export const inviteRouter = createTRPCRouter({
         expires: token.expires,
       };
     }),
-  deleteRegistrationToken: publicProcedure
+  delete: adminProcedure
     .input(z.object({ tokenId: z.string() }))
     .mutation(async ({ ctx, input }) => {
-      await ctx.prisma.registrationToken.delete({
+      await ctx.prisma.invite.delete({
         where: {
           id: input.tokenId,
         },

src/server/api/routers/user.ts

@@ -13,25 +13,25 @@ import { COOKIE_COLOR_SCHEME_KEY, COOKIE_LOCALE_KEY } from '../../../../data/con
 import { createTRPCRouter, protectedProcedure, publicProcedure } from '../trpc';
 
 export const userRouter = createTRPCRouter({
-  register: publicProcedure
+  createFromInvite: publicProcedure
     .input(
       signUpFormSchema.and(
         z.object({
-          registerToken: z.string(),
+          inviteToken: z.string(),
         })
       )
     )
     .mutation(async ({ ctx, input }) => {
-      const token = await ctx.prisma.registrationToken.findUnique({
+      const token = await ctx.prisma.invite.findUnique({
         where: {
-          token: input.registerToken,
+          token: input.inviteToken,
         },
       });
 
       if (!token || token.expires < new Date()) {
         throw new TRPCError({
           code: 'FORBIDDEN',
-          message: 'Invalid registration token',
+          message: 'Invalid invite token',
         });
       }
 
@@ -64,7 +64,7 @@ export const userRouter = createTRPCRouter({
           },
         },
       });
-      await ctx.prisma.registrationToken.delete({
+      await ctx.prisma.invite.delete({
         where: {
           id: token.id,
         },
@@ -115,7 +115,7 @@ export const userRouter = createTRPCRouter({
         },
       });
     }),
-  getWithSettings: protectedProcedure.query(async ({ ctx, input }) => {
+  withSettings: protectedProcedure.query(async ({ ctx, input }) => {
     const user = await ctx.prisma.user.findUnique({
       where: {
         id: ctx.session?.user?.id,
@@ -158,7 +158,7 @@ export const userRouter = createTRPCRouter({
       });
     }),
 
-  getAll: publicProcedure
+  all: publicProcedure
     .input(
       z.object({
         limit: z.number().min(1).max(100).default(10),
@@ -199,7 +199,7 @@ export const userRouter = createTRPCRouter({
         countPages: Math.ceil(countUsers / limit),
       };
     }),
-  createUser: publicProcedure.input(createNewUserSchema).mutation(async ({ ctx, input }) => {
+  create: publicProcedure.input(createNewUserSchema).mutation(async ({ ctx, input }) => {
     const salt = bcrypt.genSaltSync(10);
     const hashedPassword = hashPassword(input.password, salt);
     await ctx.prisma.user.create({