Add MVP version

apps/web/src/server/api/root.ts

@@ -1,5 +1,7 @@
-import { postRouter } from "~/server/api/routers/post";
+import { domainRouter } from "~/server/api/routers/domain";
 import { createCallerFactory, createTRPCRouter } from "~/server/api/trpc";
+import { apiRouter } from "./routers/api";
+import { emailRouter } from "./routers/email";
 
 /**
  * This is the primary router for your server.
@@ -7,7 +9,9 @@ import { createCallerFactory, createTRPCRouter } from "~/server/api/trpc";
  * All routers added in /api/routers should be manually added here.
  */
 export const appRouter = createTRPCRouter({
-  post: postRouter,
+  domain: domainRouter,
+  apiKey: apiRouter,
+  email: emailRouter,
 });
 
 // export type definition of API

apps/web/src/server/api/routers/api.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+import {
+  createTRPCRouter,
+  protectedProcedure,
+  publicProcedure,
+  teamProcedure,
+} from "~/server/api/trpc";
+import { db } from "~/server/db";
+import { addApiKey } from "~/server/service/api-service";
+import { createDomain, getDomain } from "~/server/service/domain-service";
+
+export const apiRouter = createTRPCRouter({
+  createToken: teamProcedure
+    .input(
+      z.object({ name: z.string(), permission: z.enum(["FULL", "SENDING"]) })
+    )
+    .mutation(async ({ ctx, input }) => {
+      return addApiKey({
+        name: input.name,
+        permission: input.permission,
+        teamId: ctx.team.id,
+      });
+    }),
+
+  getApiKeys: teamProcedure.query(async ({ ctx }) => {
+    const keys = await ctx.db.apiKey.findMany({
+      where: {
+        teamId: ctx.team.id,
+      },
+      select: {
+        id: true,
+        name: true,
+        permission: true,
+        partialToken: true,
+        lastUsed: true,
+      },
+    });
+
+    return keys;
+  }),
+});

apps/web/src/server/api/routers/domain.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+
+import {
+  createTRPCRouter,
+  protectedProcedure,
+  publicProcedure,
+  teamProcedure,
+} from "~/server/api/trpc";
+import { db } from "~/server/db";
+import { createDomain, getDomain } from "~/server/service/domain-service";
+
+export const domainRouter = createTRPCRouter({
+  createDomain: teamProcedure
+    .input(z.object({ name: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      return createDomain(ctx.team.id, input.name);
+    }),
+
+  domains: teamProcedure.query(async ({ ctx }) => {
+    const domains = await db.domain.findMany({
+      where: {
+        teamId: ctx.team.id,
+      },
+    });
+
+    return domains;
+  }),
+
+  getDomain: teamProcedure
+    .input(z.object({ id: z.number() }))
+    .query(async ({ ctx, input }) => {
+      return getDomain(input.id);
+    }),
+});

apps/web/src/server/api/routers/email.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+
+import {
+  createTRPCRouter,
+  protectedProcedure,
+  publicProcedure,
+  teamProcedure,
+} from "~/server/api/trpc";
+import { db } from "~/server/db";
+import { createDomain, getDomain } from "~/server/service/domain-service";
+
+export const emailRouter = createTRPCRouter({
+  emails: teamProcedure.query(async ({ ctx }) => {
+    const emails = await db.email.findMany({
+      where: {
+        teamId: ctx.team.id,
+      },
+    });
+
+    return emails;
+  }),
+
+  getEmail: teamProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ ctx, input }) => {
+      const email = await db.email.findUnique({
+        where: {
+          id: input.id,
+        },
+        include: {
+          emailEvents: {
+            orderBy: {
+              createdAt: "desc",
+            },
+          },
+        },
+      });
+
+      return email;
+    }),
+});

apps/web/src/server/api/routers/post.ts

@@ -1,42 +0,0 @@
-import { z } from "zod";
-
-import {
-  createTRPCRouter,
-  protectedProcedure,
-  publicProcedure,
-} from "~/server/api/trpc";
-
-export const postRouter = createTRPCRouter({
-  hello: publicProcedure
-    .input(z.object({ text: z.string() }))
-    .query(({ input }) => {
-      return {
-        greeting: `Hello ${input.text}`,
-      };
-    }),
-
-  create: protectedProcedure
-    .input(z.object({ name: z.string().min(1) }))
-    .mutation(async ({ ctx, input }) => {
-      // simulate a slow db call
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
-      return ctx.db.post.create({
-        data: {
-          name: input.name,
-          createdBy: { connect: { id: ctx.session.user.id } },
-        },
-      });
-    }),
-
-  getLatest: protectedProcedure.query(({ ctx }) => {
-    return ctx.db.post.findFirst({
-      orderBy: { createdAt: "desc" },
-      where: { createdBy: { id: ctx.session.user.id } },
-    });
-  }),
-
-  getSecretMessage: protectedProcedure.query(() => {
-    return "you can now see this secret message!";
-  }),
-});

apps/web/src/server/api/trpc.ts

@@ -9,7 +9,7 @@
 
 import { initTRPC, TRPCError } from "@trpc/server";
 import superjson from "superjson";
-import { ZodError } from "zod";
+import { z, ZodError } from "zod";
 
 import { getServerAuthSession } from "~/server/auth";
 import { db } from "~/server/db";
@@ -106,3 +106,21 @@ export const protectedProcedure = t.procedure.use(({ ctx, next }) => {
     },
   });
 });
+
+export const teamProcedure = protectedProcedure.use(
+  async ({ ctx, next, input }) => {
+    const teamUser = await db.teamUser.findFirst({
+      where: { userId: ctx.session.user.id },
+      include: { team: true },
+    });
+    if (!teamUser) {
+      throw new TRPCError({ code: "NOT_FOUND", message: "Team not found" });
+    }
+    return next({
+      ctx: {
+        team: teamUser.team,
+        session: { ...ctx.session, user: ctx.session.user },
+      },
+    });
+  }
+);