Rename Organization to Project

We'll probably need a concept of organizations at some point in the future, but in practice the way we're using these in the codebase right now is as a project, so this renames it to that to avoid confusion.
2023-08-09 15:49:19 -07:00
parent ac99c8e0f7
commit 16aa6672fc
30 changed files with 292 additions and 248 deletions
--- a/app/src/server/api/root.router.ts
+++ b/app/src/server/api/root.router.ts
@@ -9,7 +9,7 @@ import { worldChampsRouter } from "./routers/worldChamps.router";
 import { datasetsRouter } from "./routers/datasets.router";
 import { datasetEntries } from "./routers/datasetEntries.router";
 import { externalApiRouter } from "./routers/externalApi.router";
-import { organizationsRouter } from "./routers/organizations.router";
+import { projectsRouter } from "./routers/projects.router";
 import { dashboardRouter } from "./routers/dashboard.router";

 /**
@@ -27,7 +27,7 @@ export const appRouter = createTRPCRouter({
  worldChamps: worldChampsRouter,
  datasets: datasetsRouter,
  datasetEntries: datasetEntries,
-  organizations: organizationsRouter,
+  projects: projectsRouter,
  dashboard: dashboardRouter,
  externalApi: externalApiRouter,
 });
--- a/app/src/server/api/routers/dashboard.router.ts
+++ b/app/src/server/api/routers/dashboard.router.ts
@@ -10,7 +10,7 @@ export const dashboardRouter = createTRPCRouter({
      z.object({
        // TODO: actually take startDate into account
        startDate: z.string().optional(),
-        organizationId: z.string(),
+        projectId: z.string(),
      }),
    )
    .query(async ({ input }) => {
@@ -22,7 +22,7 @@ export const dashboardRouter = createTRPCRouter({
          "LoggedCall.id",
          "LoggedCallModelResponse.originalLoggedCallId",
        )
-        .where("organizationId", "=", input.organizationId)
+        .where("projectId", "=", input.projectId)
        .select(({ fn }) => [
          sql<Date>`date_trunc('day', "LoggedCallModelResponse"."startTime")`.as("period"),
          sql<number>`count("LoggedCall"."id")::int`.as("numQueries"),
@@ -70,7 +70,7 @@ export const dashboardRouter = createTRPCRouter({
          "LoggedCall.id",
          "LoggedCallModelResponse.originalLoggedCallId",
        )
-        .where("organizationId", "=", input.organizationId)
+        .where("projectId", "=", input.projectId)
        .select(({ fn }) => [
          fn.sum(fn.coalesce("LoggedCallModelResponse.totalCost", sql<number>`0`)).as("totalCost"),
          fn.count("LoggedCall.id").as("numQueries"),
@@ -79,7 +79,7 @@ export const dashboardRouter = createTRPCRouter({

      const errors = await kysely
        .selectFrom("LoggedCall")
-        .where("organizationId", "=", input.organizationId)
+        .where("projectId", "=", input.projectId)
        .leftJoin(
          "LoggedCallModelResponse",
          "LoggedCall.id",
--- a/app/src/server/api/routers/datasets.router.ts
+++ b/app/src/server/api/routers/datasets.router.ts
@@ -3,20 +3,20 @@ import { createTRPCRouter, protectedProcedure, publicProcedure } from "~/server/
 import { prisma } from "~/server/db";
 import {
  requireCanModifyDataset,
-  requireCanModifyOrganization,
+  requireCanModifyProject,
  requireCanViewDataset,
-  requireCanViewOrganization,
+  requireCanViewProject,
 } from "~/utils/accessControl";

 export const datasetsRouter = createTRPCRouter({
  list: protectedProcedure
-    .input(z.object({ organizationId: z.string() }))
+    .input(z.object({ projectId: z.string() }))
    .query(async ({ input, ctx }) => {
-      await requireCanViewOrganization(input.organizationId, ctx);
+      await requireCanViewProject(input.projectId, ctx);

      const datasets = await prisma.dataset.findMany({
        where: {
-          organizationId: input.organizationId,
+          projectId: input.projectId,
        },
        orderBy: {
          createdAt: "desc",
@@ -36,26 +36,26 @@ export const datasetsRouter = createTRPCRouter({
    return await prisma.dataset.findFirstOrThrow({
      where: { id: input.id },
      include: {
-        organization: true,
+        project: true,
      },
    });
  }),

  create: protectedProcedure
-    .input(z.object({ organizationId: z.string() }))
+    .input(z.object({ projectId: z.string() }))
    .mutation(async ({ input, ctx }) => {
-      await requireCanModifyOrganization(input.organizationId, ctx);
+      await requireCanModifyProject(input.projectId, ctx);

      const numDatasets = await prisma.dataset.count({
        where: {
-          organizationId: input.organizationId,
+          projectId: input.projectId,
        },
      });

      return await prisma.dataset.create({
        data: {
          name: `Dataset ${numDatasets + 1}`,
-          organizationId: input.organizationId,
+          projectId: input.projectId,
        },
      });
    }),
--- a/app/src/server/api/routers/experiments.router.ts
+++ b/app/src/server/api/routers/experiments.router.ts
@@ -8,9 +8,9 @@ import { generateNewCell } from "~/server/utils/generateNewCell";
 import {
  canModifyExperiment,
  requireCanModifyExperiment,
-  requireCanModifyOrganization,
+  requireCanModifyProject,
  requireCanViewExperiment,
-  requireCanViewOrganization,
+  requireCanViewProject,
 } from "~/utils/accessControl";
 import generateTypes from "~/modelProviders/generateTypes";
 import { promptConstructorVersion } from "~/promptConstructor/version";
@@ -44,13 +44,13 @@ export const experimentsRouter = createTRPCRouter({
    };
  }),
  list: protectedProcedure
-    .input(z.object({ organizationId: z.string() }))
+    .input(z.object({ projectId: z.string() }))
    .query(async ({ input, ctx }) => {
-      await requireCanViewOrganization(input.organizationId, ctx);
+      await requireCanViewProject(input.projectId, ctx);

      const experiments = await prisma.experiment.findMany({
        where: {
-          organizationId: input.organizationId,
+          projectId: input.projectId,
        },
        orderBy: {
          sortIndex: "desc",
@@ -90,7 +90,7 @@ export const experimentsRouter = createTRPCRouter({
    const experiment = await prisma.experiment.findFirstOrThrow({
      where: { id: input.id },
      include: {
-        organization: true,
+        project: true,
      },
    });

@@ -108,10 +108,10 @@ export const experimentsRouter = createTRPCRouter({
  }),

  fork: protectedProcedure
-    .input(z.object({ id: z.string(), organizationId: z.string() }))
+    .input(z.object({ id: z.string(), projectId: z.string() }))
    .mutation(async ({ input, ctx }) => {
      await requireCanViewExperiment(input.id, ctx);
-      await requireCanModifyOrganization(input.organizationId, ctx);
+      await requireCanModifyProject(input.projectId, ctx);

      const [
        existingExp,
@@ -264,7 +264,7 @@ export const experimentsRouter = createTRPCRouter({
            id: newExperimentId,
            sortIndex: maxSortIndex + 1,
            label: `${existingExp.label} (forked)`,
-            organizationId: input.organizationId,
+            projectId: input.projectId,
          },
        }),
        prisma.promptVariant.createMany({
@@ -294,9 +294,9 @@ export const experimentsRouter = createTRPCRouter({
    }),

  create: protectedProcedure
-    .input(z.object({ organizationId: z.string() }))
+    .input(z.object({ projectId: z.string() }))
    .mutation(async ({ input, ctx }) => {
-      await requireCanModifyOrganization(input.organizationId, ctx);
+      await requireCanModifyProject(input.projectId, ctx);

      const maxSortIndex =
        (
@@ -304,7 +304,7 @@ export const experimentsRouter = createTRPCRouter({
            _max: {
              sortIndex: true,
            },
-            where: { organizationId: input.organizationId },
+            where: { projectId: input.projectId },
          })
        )._max?.sortIndex ?? 0;

@@ -312,7 +312,7 @@ export const experimentsRouter = createTRPCRouter({
        data: {
          sortIndex: maxSortIndex + 1,
          label: `Experiment ${maxSortIndex + 1}`,
-          organizationId: input.organizationId,
+          projectId: input.projectId,
        },
      });

--- a/app/src/server/api/routers/externalApi.router.ts
+++ b/app/src/server/api/routers/externalApi.router.ts
@@ -66,7 +66,7 @@ export const externalApiRouter = createTRPCRouter({
        throw new TRPCError({ code: "UNAUTHORIZED" });
      }
      const reqPayload = await reqValidator.spa(input.reqPayload);
-      const cacheKey = hashRequest(key.organizationId, reqPayload as JsonValue);
+      const cacheKey = hashRequest(key.projectId, reqPayload as JsonValue);

      const existingResponse = await prisma.loggedCallModelResponse.findFirst({
        where: {
@@ -84,7 +84,7 @@ export const externalApiRouter = createTRPCRouter({

      await prisma.loggedCall.create({
        data: {
-          organizationId: key.organizationId,
+          projectId: key.projectId,
          startTime: new Date(input.startTime),
          cacheHit: true,
          modelResponseId: existingResponse.id,
@@ -135,7 +135,7 @@ export const externalApiRouter = createTRPCRouter({
      const reqPayload = await reqValidator.spa(input.reqPayload);
      const respPayload = await respValidator.spa(input.respPayload);

-      const requestHash = hashRequest(key.organizationId, reqPayload as JsonValue);
+      const requestHash = hashRequest(key.projectId, reqPayload as JsonValue);

      const newLoggedCallId = uuidv4();
      const newModelResponseId = uuidv4();
@@ -146,7 +146,7 @@ export const externalApiRouter = createTRPCRouter({
        prisma.loggedCall.create({
          data: {
            id: newLoggedCallId,
-            organizationId: key.organizationId,
+            projectId: key.projectId,
            startTime: new Date(input.startTime),
            cacheHit: false,
          },
--- a/app/src/server/api/routers/organizations.router.ts
+++ b/app/src/server/api/routers/organizations.router.ts
@@ -5,15 +5,15 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "~/server/api/trpc";
 import { prisma } from "~/server/db";
 import { generateApiKey } from "~/server/utils/generateApiKey";
-import userOrg from "~/server/utils/userOrg";
+import userProject from "~/server/utils/userProject";
 import {
-  requireCanModifyOrganization,
-  requireCanViewOrganization,
-  requireIsOrgAdmin,
+  requireCanModifyProject,
+  requireCanViewProject,
+  requireIsProjectAdmin,
  requireNothing,
 } from "~/utils/accessControl";

-export const organizationsRouter = createTRPCRouter({
+export const projectsRouter = createTRPCRouter({
  list: protectedProcedure.query(async ({ ctx }) => {
    const userId = ctx.session.user.id;
    requireNothing(ctx);
@@ -22,9 +22,9 @@ export const organizationsRouter = createTRPCRouter({
      return null;
    }

-    const organizations = await prisma.organization.findMany({
+    const projects = await prisma.project.findMany({
      where: {
-        organizationUsers: {
+        projectUsers: {
          some: { userId: ctx.session.user.id },
        },
      },
@@ -33,30 +33,30 @@ export const organizationsRouter = createTRPCRouter({
      },
    });

-    if (!organizations.length) {
+    if (!projects.length) {
      // TODO: We should move this to a separate endpoint that is called on sign up
-      const personalOrg = await userOrg(userId);
-      organizations.push(personalOrg);
+      const personalProject = await userProject(userId);
+      projects.push(personalProject);
    }

-    return organizations;
+    return projects;
  }),
  get: protectedProcedure.input(z.object({ id: z.string() })).query(async ({ input, ctx }) => {
-    await requireCanViewOrganization(input.id, ctx);
-    const [org, userRole] = await prisma.$transaction([
-      prisma.organization.findUnique({
+    await requireCanViewProject(input.id, ctx);
+    const [proj, userRole] = await prisma.$transaction([
+      prisma.project.findUnique({
        where: {
          id: input.id,
        },
        include: {
          apiKeys: true,
-          personalOrgUser: true,
+          personalProjectUser: true,
        },
      }),
-      prisma.organizationUser.findFirst({
+      prisma.projectUser.findFirst({
        where: {
          userId: ctx.session.user.id,
-          organizationId: input.id,
+          projectId: input.id,
          role: {
            in: ["ADMIN", "MEMBER"],
          },
@@ -64,20 +64,20 @@ export const organizationsRouter = createTRPCRouter({
      }),
    ]);

-    if (!org) {
+    if (!proj) {
      throw new TRPCError({ code: "NOT_FOUND" });
    }

    return {
-      ...org,
+      ...proj,
      role: userRole?.role ?? null,
    };
  }),
  update: protectedProcedure
    .input(z.object({ id: z.string(), updates: z.object({ name: z.string() }) }))
    .mutation(async ({ input, ctx }) => {
-      await requireCanModifyOrganization(input.id, ctx);
-      return await prisma.organization.update({
+      await requireCanModifyProject(input.id, ctx);
+      return await prisma.project.update({
        where: {
          id: input.id,
        },
@@ -90,36 +90,36 @@ export const organizationsRouter = createTRPCRouter({
    .input(z.object({ name: z.string() }))
    .mutation(async ({ input, ctx }) => {
      requireNothing(ctx);
-      const newOrgId = uuidv4();
-      const [newOrg] = await prisma.$transaction([
-        prisma.organization.create({
+      const newProjectId = uuidv4();
+      const [newProject] = await prisma.$transaction([
+        prisma.project.create({
          data: {
-            id: newOrgId,
+            id: newProjectId,
            name: input.name,
          },
        }),
-        prisma.organizationUser.create({
+        prisma.projectUser.create({
          data: {
            userId: ctx.session.user.id,
-            organizationId: newOrgId,
+            projectId: newProjectId,
            role: "ADMIN",
          },
        }),
        prisma.apiKey.create({
          data: {
            name: "Default API Key",
-            organizationId: newOrgId,
+            projectId: newProjectId,
            apiKey: generateApiKey(),
          },
        }),
      ]);
-      return newOrg;
+      return newProject;
    }),
  delete: protectedProcedure
    .input(z.object({ id: z.string() }))
    .mutation(async ({ input, ctx }) => {
-      await requireIsOrgAdmin(input.id, ctx);
-      return await prisma.organization.delete({
+      await requireIsProjectAdmin(input.id, ctx);
+      return await prisma.project.delete({
        where: {
          id: input.id,
        },