feature: tenancy

apps/web/src/actions/documents/create.ts

@@ -1,7 +1,6 @@
 'use server'
 
-import { createNewDocument } from '@latitude-data/core'
-import { findCommit } from '$/app/(private)/_data-access'
+import { CommitsRepository, createNewDocument } from '@latitude-data/core'
 import { z } from 'zod'
 
 import { withProject } from '../procedures'
@@ -15,14 +14,15 @@ export const createDocumentVersionAction = withProject
     }),
     { type: 'json' },
   )
-  .handler(async ({ input }) => {
-    const commit = await findCommit({
-      projectId: input.projectId,
-      uuid: input.commitUuid,
-    })
+  .handler(async ({ input, ctx }) => {
+    const commit = await new CommitsRepository(ctx.project.workspaceId)
+      .getCommitByUuid({ uuid: input.commitUuid, projectId: ctx.project.id })
+      .then((r) => r.unwrap())
+
     const result = await createNewDocument({
-      commitId: commit.id,
+      commit,
       path: input.path,
     })
+
     return result.unwrap()
   })

apps/web/src/actions/procedures/index.ts

@@ -1,4 +1,4 @@
-import { findProject } from '@latitude-data/core'
+import { ProjectsRepository } from '@latitude-data/core'
 import { getCurrentUser } from '$/services/auth/getCurrentUser'
 import { z } from 'zod'
 import { createServerActionProcedure } from 'zsa'
@@ -16,11 +16,11 @@ export const authProcedure = createServerActionProcedure().handler(async () => {
 export const withProject = createServerActionProcedure(authProcedure)
   .input(z.object({ projectId: z.number() }))
   .handler(async ({ input, ctx }) => {
+    const { workspace } = ctx
+    const projectScope = new ProjectsRepository(workspace.id)
     const project = (
-      await findProject({
-        projectId: input.projectId,
-        workspaceId: ctx.workspace.id,
-      })
+      await projectScope.getProjectById(input.projectId)
     ).unwrap()
+
     return { ...ctx, project }
   })

apps/web/src/actions/user/setupAction.ts

@@ -24,7 +24,6 @@ export const setupAction = createServerAction()
   )
   .handler(async ({ input }) => {
     const itWasAlreadySetup = await isWorkspaceCreated()
-
     if (itWasAlreadySetup) {
       throw new Error('Workspace already created')
     }

apps/web/src/app/(private)/_data-access/index.ts

@@ -1,34 +1,44 @@
 import { cache } from 'react'
 
 import {
-  findCommitByUuid as originalfindCommit,
-  findProject as originalFindProject,
-  getFirstProject as originalGetFirstProject,
-  type FindCommitByUuidProps,
-  type FindProjectProps,
+  CommitsRepository,
+  Project,
+  ProjectsRepository,
 } from '@latitude-data/core'
 
 export const getFirstProject = cache(
   async ({ workspaceId }: { workspaceId: number }) => {
-    const result = await originalGetFirstProject({ workspaceId })
+    const projectsScope = new ProjectsRepository(workspaceId)
+    const result = await projectsScope.getFirstProject()
     const project = result.unwrap()
 
     return project
   },
 )
 
 export const findProject = cache(
-  async ({ projectId, workspaceId }: FindProjectProps) => {
-    const result = await originalFindProject({ projectId, workspaceId })
+  async ({
+    projectId,
+    workspaceId,
+  }: {
+    projectId: number
+    workspaceId: number
+  }) => {
+    const projectsScope = new ProjectsRepository(workspaceId)
+    const result = await projectsScope.getProjectById(projectId)
     const project = result.unwrap()
 
     return project
   },
 )
 
 export const findCommit = cache(
-  async ({ uuid, projectId }: FindCommitByUuidProps) => {
-    const result = await originalfindCommit({ uuid, projectId })
+  async ({ uuid, project }: { uuid: string; project: Project }) => {
+    const commitsScope = new CommitsRepository(project.workspaceId)
+    const result = await commitsScope.getCommitByUuid({
+      projectId: project.id,
+      uuid,
+    })
     const commit = result.unwrap()
 
     return commit

apps/web/src/app/(private)/api/v1/projects/[projectId]/commits/[commitUuid]/[...documentPath]/route.test.ts

@@ -15,7 +15,7 @@ describe('GET documentVersion', () => {
       commit,
     })
 
-    await mergeCommit({ commitId: commit.id })
+    await mergeCommit(commit)
 
     const response = await GET(
       new NextRequest(
@@ -41,7 +41,7 @@ describe('GET documentVersion', () => {
       commit,
     })
 
-    await mergeCommit({ commitId: commit.id })
+    await mergeCommit(commit)
 
     const response = await GET(
       new NextRequest(
@@ -64,7 +64,7 @@ describe('GET documentVersion', () => {
     const { project } = await ctx.factories.createProject()
     const { commit } = await ctx.factories.createDraft({ project })
 
-    await mergeCommit({ commitId: commit.id })
+    await mergeCommit(commit)
 
     const response = await GET(
       new NextRequest(

apps/web/src/app/(private)/api/v1/projects/[projectId]/commits/[commitUuid]/[...documentPath]/route.ts

@@ -1,9 +1,12 @@
-import { getDocumentByPath } from '@latitude-data/core'
+import {
+  CommitsRepository,
+  DocumentVersionsRepository,
+} from '@latitude-data/core'
 import apiRoute from '$/helpers/api/route'
-import { NextRequest } from 'next/server'
+import { LatitudeRequest } from '$/middleware'
 
 export async function GET(
-  _: NextRequest,
+  req: LatitudeRequest,
   {
     params,
   }: {
@@ -15,11 +18,15 @@ export async function GET(
   },
 ) {
   return apiRoute(async () => {
-    const { projectId, commitUuid, documentPath } = params
-
-    const result = await getDocumentByPath({
-      projectId: Number(projectId),
-      commitUuid,
+    const workspaceId = req.workspaceId!
+    const { commitUuid, projectId, documentPath } = params
+    const commitsScope = new CommitsRepository(workspaceId)
+    const commit = await commitsScope
+      .getCommitByUuid({ uuid: commitUuid, projectId })
+      .then((r) => r.unwrap())
+    const documentVersionsScope = new DocumentVersionsRepository(workspaceId)
+    const result = await documentVersionsScope.getDocumentByPath({
+      commit,
       path: documentPath.join('/'),
     })
     const document = result.unwrap()

apps/web/src/app/(private)/page.tsx

@@ -15,7 +15,9 @@ export default async function AppRoot() {
   try {
     session = await getCurrentUser()
     project = await getFirstProject({ workspaceId: session.workspace.id })
-    await findCommit({ uuid: HEAD_COMMIT, projectId: project.id })
+
+    await findCommit({ uuid: HEAD_COMMIT, project })
+
     url = PROJECT_ROUTE({ id: project.id }).commits.latest
   } catch (error) {
     if (error instanceof NotFoundError) {

apps/web/src/app/(private)/projects/[projectId]/page.tsx

@@ -18,10 +18,10 @@ export default async function ProjectPage({ params }: ProjectPageParams) {
   try {
     session = await getCurrentUser()
     project = await findProject({
-      projectId: params.projectId,
+      projectId: Number(params.projectId),
       workspaceId: session.workspace.id,
     })
-    await findCommit({ uuid: HEAD_COMMIT, projectId: project.id })
+    await findCommit({ uuid: HEAD_COMMIT, project })
     url = PROJECT_ROUTE({ id: +project.id }).commits.latest
   } catch (error) {
     if (error instanceof NotFoundError) {

apps/web/src/app/(private)/projects/[projectId]/versions/[commitUuid]/layout.tsx

@@ -2,13 +2,14 @@ import { ReactNode } from 'react'
 
 import {
   Commit,
+  CommitsRepository,
   HEAD_COMMIT,
   NotFoundError,
   Project,
+  ProjectsRepository,
 } from '@latitude-data/core'
 import { CommitProvider, ProjectProvider } from '@latitude-data/web-ui'
 import { AppLayout, BreadcrumpBadge } from '@latitude-data/web-ui/browser'
-import { findCommit, findProject } from '$/app/(private)/_data-access'
 import { NAV_LINKS } from '$/app/(private)/_lib/constants'
 import { ProjectPageParams } from '$/app/(private)/projects/[projectId]/page'
 import { getCurrentUser, SessionData } from '$/services/auth/getCurrentUser'
@@ -29,18 +30,20 @@ export default async function CommitLayout({
   let commit: Commit
   try {
     session = await getCurrentUser()
-    project = await findProject({
-      projectId: params.projectId,
-      workspaceId: session.workspace.id,
-    })
-    commit = await findCommit({
-      uuid: params.commitUuid,
-      projectId: project.id,
-    })
+    const projectsRepo = new ProjectsRepository(session.workspace.id)
+    const commitsRepo = new CommitsRepository(session.workspace.id)
+    project = (
+      await projectsRepo.getProjectById(Number(params.projectId))
+    ).unwrap()
+    commit = (
+      await commitsRepo.getCommitByUuid({
+        uuid: params.commitUuid,
+        projectId: project.id,
+      })
+    ).unwrap()
   } catch (error) {
-    if (error instanceof NotFoundError) {
-      return notFound()
-    }
+    if (error instanceof NotFoundError) return notFound()
+
     throw error
   }
 

apps/web/src/app/api/projects/[projectId]/commits/[commitUuid]/documents/route.ts

@@ -0,0 +1,28 @@
+import {
+  CommitsRepository,
+  DocumentVersionsRepository,
+} from '@latitude-data/core'
+import { LatitudeRequest } from '$/middleware'
+import { NextResponse } from 'next/server'
+
+export async function GET(
+  req: LatitudeRequest,
+  {
+    params: { commitUuid, projectId },
+  }: { params: { commitUuid: string; projectId: number } },
+) {
+  try {
+    const workspaceId = req.workspaceId!
+    const scope = new DocumentVersionsRepository(workspaceId)
+    const commitsScope = new CommitsRepository(workspaceId)
+    const commit = await commitsScope
+      .getCommitByUuid({ uuid: commitUuid, projectId })
+      .then((r) => r.unwrap())
+    const documents = await scope.getDocumentsAtCommit(commit)
+
+    return NextResponse.json(documents.unwrap())
+  } catch (err: unknown) {
+    const error = err as Error
+    return NextResponse.json({ error: error.message }, { status: 500 })
+  }
+}

apps/web/src/components/Sidebar/index.tsx

@@ -1,20 +1,31 @@
-import { getDocumentsAtCommit } from '@latitude-data/core'
-import { findCommit } from '$/app/(private)/_data-access'
+import {
+  CommitsRepository,
+  DocumentVersionsRepository,
+  Project,
+} from '@latitude-data/core'
 
 import DocumentTree, { CreateNode } from './DocumentTree'
 
 export default async function Sidebar({
   commitUuid,
-  projectId,
+  project,
 }: {
   commitUuid: string
-  projectId: number
+  project: Project
 }) {
-  const commit = await findCommit({ projectId, uuid: commitUuid })
-  const documentsResult = await getDocumentsAtCommit({
-    commitId: commit.id,
-  })
-  const documents = documentsResult.unwrap()
+  const commitsScope = new CommitsRepository(project.workspaceId)
+  const commit = await commitsScope
+    .getCommitByUuid({
+      uuid: commitUuid,
+      projectId: project.id,
+    })
+    .then((r) => r.unwrap())
+  const documentVersionsScope = new DocumentVersionsRepository(
+    project.workspaceId,
+  )
+  const documents = await documentVersionsScope
+    .getDocumentsAtCommit(commit)
+    .then((r) => r.unwrap())
 
   return (
     <div className='flex flex-col gap-4 p-4'>

apps/web/src/data-access/users.ts

@@ -1,6 +1,6 @@
 import {
   database,
-  getUser,
+  unsafelyGetUser,
   NotFoundError,
   Result,
   users,
@@ -31,15 +31,12 @@ export async function getUserFromCredentials({
     },
     where: eq(users.email, email),
   })
-
   if (!user) return notFound()
 
   const validPassword = await verifyPassword(password, user.encryptedPassword)
-
   if (!validPassword) notFound()
 
   const wpResult = await getWorkspace({ userId: user.id })
-
   if (wpResult.error) {
     return Result.error(wpResult.error)
   }
@@ -60,7 +57,7 @@ export async function getCurrentUserFromDB({
 }: {
   userId: string | undefined
 }): PromisedResult<SessionData, NotFoundError> {
-  const user = await getUser(userId)
+  const user = await unsafelyGetUser(userId)
   if (!user) return notFound()
 
   const wpResult = await getWorkspace({ userId: user.id })

apps/web/src/middleware.ts

@@ -1,4 +1,4 @@
-import { getApiKey } from '@latitude-data/core'
+import { unsafelyGetApiKey } from '@latitude-data/core'
 import { NextRequest, NextResponse } from 'next/server'
 
 import env from './env'
@@ -15,7 +15,7 @@ export async function middleware(request: LatitudeRequest) {
     return apiUnauthorized()
   }
 
-  const result = await getApiKey({ uuid: token })
+  const result = await unsafelyGetApiKey({ uuid: token })
   if (result.error) return apiUnauthorized()
 
   request.workspaceId = result.value.workspaceId

packages/core/src/data-access/apiKeys.ts

@@ -3,8 +3,13 @@ import { NotFoundError, Result } from '$core/lib'
 import { apiKeys } from '$core/schema'
 import { eq } from 'drizzle-orm'
 
-export async function getApiKey({ uuid }: { uuid: string }, db = database) {
-  const apiKey = await db.query.apiKeys.findFirst({ where: eq(apiKeys, uuid) })
+export async function unsafelyGetApiKey(
+  { uuid }: { uuid: string },
+  db = database,
+) {
+  const apiKey = await db.query.apiKeys.findFirst({
+    where: eq(apiKeys.uuid, uuid),
+  })
   if (!apiKey) return Result.error(new NotFoundError('API key not found'))
 
   return Result.ok(apiKey)