Current commit management

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

@@ -0,0 +1,19 @@
+'use server'
+
+import { isCommitDraft } from '@latitude-data/core'
+import { z } from 'zod'
+
+import { authProcedure } from '../procedures'
+
+export const checkCommitEditableAction = authProcedure
+  .createServerAction()
+  .input(
+    z.object({
+      commitUuid: z.string(),
+    }),
+    { type: 'json' },
+  )
+  .handler(async ({ input }) => {
+    const res = await isCommitDraft({ uuid: input.commitUuid })
+    return res.unwrap()
+  })

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

@@ -0,0 +1,11 @@
+import { DocumentEditor } from '@latitude-data/web-ui'
+
+export const dynamic = 'force-dynamic'
+
+export default async function Editor() {
+  return (
+    <div className='w-full h-full relative'>
+      <DocumentEditor document='' />
+    </div>
+  )
+}

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

@@ -1,8 +1,9 @@
 import { ReactNode } from 'react'
 
-import Sidebar from '$/components/Sidebar'
+// import Sidebar from '$/components/Sidebar'
 import { getSession } from '$/services/auth/getSession'
 import { ROUTES } from '$/services/routes'
+import { CommitProvider } from '$/stores/commitContext'
 import { redirect } from 'next/navigation'
 
 export default async function PrivateLayout({
@@ -15,11 +16,11 @@ export default async function PrivateLayout({
     return redirect(ROUTES.auth.login)
   }
   return (
-    <main className='flex flex-row w-full'>
-      <div className='w-[280px]'>
-        <Sidebar />
-      </div>
-      <div className='flex-1'>{children}</div>
-    </main>
+    <CommitProvider>
+      <main className='flex flex-row w-full'>
+        <div className='w-[280px]'>{/* <Sidebar /> */}</div>
+        <div className='flex-1'>{children}</div>
+      </main>
+    </CommitProvider>
   )
 }

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

@@ -2,12 +2,11 @@ import { materializeDocumentsAtCommit } from '@latitude-data/core'
 import { NextRequest, NextResponse } from 'next/server'
 
 export async function GET(
-  req: NextRequest,
+  _: NextRequest,
   { commitUuid }: { commitUuid: string },
 ) {
   try {
-    const staged = Boolean(req.nextUrl.searchParams.get('staged') || false)
-    const nodes = await materializeDocumentsAtCommit({ commitUuid, staged })
+    const nodes = await materializeDocumentsAtCommit({ commitUuid })
 
     return NextResponse.json(nodes)
   } catch (err: unknown) {

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

@@ -2,6 +2,7 @@
 
 import { faker } from '@faker-js/faker'
 import type { DocumentType, DocumentVersion } from '@latitude-data/core'
+import { useCurrentCommit } from '$/stores/commitContext'
 import useDocumentVersions from '$/stores/documentVersions'
 
 import toTree, { Node } from '../toTree'
@@ -20,26 +21,36 @@ export function CreateNode({ parentId }: { parentId?: number }) {
 }
 
 function CreateFolder({ parentId }: { parentId?: number }) {
-  const { create } = useDocumentVersions({ staged: true })
+  const { currentCommit, isCommitEditable } = useCurrentCommit()
+  const { create } = useDocumentVersions({ commitUuid: currentCommit })
   return (
     <button
-      onClick={() =>
+      disabled={!isCommitEditable}
+      onClick={() => {
+        if (!isCommitEditable) return
         create({
           parentId,
           documentType: 'folder' as DocumentType.Folder,
           name: generateName(),
         })
-      }
+      }}
     >
       +F
     </button>
   )
 }
 
 function CreateDocument({ parentId }: { parentId?: number }) {
-  const { create } = useDocumentVersions({ staged: true })
+  const { currentCommit, isCommitEditable } = useCurrentCommit()
+  const { create } = useDocumentVersions({ commitUuid: currentCommit })
   return (
-    <button onClick={() => create({ parentId, name: generateName() })}>
+    <button
+      disabled={!isCommitEditable}
+      onClick={() => {
+        if (!isCommitEditable) return
+        create({ parentId, name: generateName() })
+      }}
+    >
       +D
     </button>
   )
@@ -70,8 +81,9 @@ function TreeNode({ node, level = 0 }: { node: Node; level?: number }) {
 }
 
 export default function DocumentTree({ nodes }: { nodes: DocumentVersion[] }) {
+  const { currentCommit } = useCurrentCommit()
   const { data } = useDocumentVersions(
-    { staged: true },
+    { commitUuid: currentCommit },
     { fallbackData: nodes },
   )
   const rootNode = toTree(data)

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

@@ -5,7 +5,6 @@ import DocumentTree, { CreateNode } from './DocumentTree'
 export default async function Sidebar() {
   const nodes = await materializeDocumentsAtCommit({
     commitUuid: HEAD_COMMIT,
-    staged: true,
   })
 
   return (

apps/web/src/stores/commitContext.tsx

@@ -0,0 +1,81 @@
+import {
+  createContext,
+  ReactNode,
+  useContext,
+  useEffect,
+  useState,
+} from 'react'
+
+import { checkCommitEditableAction } from '$/actions/commits'
+
+interface CommitContextType {
+  currentCommit?: string
+  isCommitEditable: boolean
+  setCurrentCommit: ({
+    commitUuid,
+    isEditable,
+  }: {
+    commitUuid?: string
+    isEditable: boolean
+  }) => void
+}
+
+const CommitContext = createContext<CommitContextType>({
+  currentCommit: undefined,
+  isCommitEditable: false,
+  setCurrentCommit: () => {},
+})
+
+export const CommitProvider = ({ children }: { children: ReactNode }) => {
+  const [currentCommit, setCurrentCommit] = useState<string | undefined>()
+  const [isCommitEditable, setIsCommitEditable] = useState<boolean>(false)
+
+  useEffect(() => {
+    const storedCommit = localStorage.getItem('commit')
+    if (!storedCommit) {
+      setCurrentCommit(undefined)
+      setIsCommitEditable(false)
+      return
+    }
+
+    setCurrentCommit(storedCommit)
+    checkCommitEditableAction({ commitUuid: storedCommit }).then((res) => {
+      setIsCommitEditable(res[0]!)
+    })
+  }, [])
+
+  const updateCurrentCommit = ({
+    commitUuid,
+    isEditable,
+  }: {
+    commitUuid?: string
+    isEditable: boolean
+  }) => {
+    setCurrentCommit(commitUuid)
+    setIsCommitEditable(isEditable)
+
+    if (commitUuid) {
+      localStorage.setItem('commit', commitUuid)
+    } else {
+      localStorage.removeItem('commit')
+    }
+  }
+
+  return (
+    <CommitContext.Provider
+      value={{
+        currentCommit,
+        isCommitEditable,
+        setCurrentCommit: updateCurrentCommit,
+      }}
+    >
+      {children}
+    </CommitContext.Provider>
+  )
+}
+
+export const useCurrentCommit = () => {
+  const { currentCommit, isCommitEditable, setCurrentCommit } =
+    useContext(CommitContext)
+  return { currentCommit, isCommitEditable, setCurrentCommit }
+}

apps/web/src/stores/documentVersions.ts

@@ -6,26 +6,19 @@ import useSWR, { SWRConfiguration } from 'swr'
 
 export default function useDocumentVersions(
   {
-    commitUuid = HEAD_COMMIT,
-    staged = false,
+    commitUuid,
   }: {
     commitUuid?: string
-    staged?: boolean
   },
   opts?: SWRConfiguration,
 ) {
-  const key =
-    `/api/commits/${commitUuid}/documents?` +
-    new URLSearchParams({
-      staged: String(staged),
-    }).toString()
+  const key = `/api/commits/${commitUuid ?? HEAD_COMMIT}/documents`
   const { mutate, data, ...rest } = useSWR(
     key,
     (url: string) => fetch(url).then((res) => res.json()),
     opts,
   )
   const create = async (payload: {
-    commitUuid?: string
     name: string
     documentType?: DocumentVersion['documentType']
     parentId?: number
@@ -34,7 +27,7 @@ export default function useDocumentVersions(
       const doc = await createDocumentVersionAction({
         ...payload,
         name: payload.name!,
-        commitUuid: payload.commitUuid || HEAD_COMMIT,
+        commitUuid: commitUuid || HEAD_COMMIT,
       })
       mutate([...data, doc])
 

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

@@ -1,4 +1,11 @@
-import { commits, database, HEAD_COMMIT } from '@latitude-data/core'
+import {
+  commits,
+  database,
+  HEAD_COMMIT,
+  Result,
+  TypedResult,
+} from '@latitude-data/core'
+import { LatitudeError, NotFoundError } from '$core/lib/errors'
 import { desc, eq, isNull } from 'drizzle-orm'
 
 export async function findCommit({ uuid }: { uuid?: string }, tx = database) {
@@ -27,6 +34,25 @@ export async function listCommits() {
   return database.select().from(commits)
 }
 
-export async function listStagedCommits() {
-  return database.select().from(commits).where(isNull(commits.nextCommitId))
+export async function isCommitDraft(
+  { uuid }: { uuid: string },
+  tx = database,
+): Promise<TypedResult<boolean, LatitudeError>> {
+  const res = await tx
+    .select()
+    .from(commits)
+    .where(eq(commits.uuid, uuid))
+    .limit(1)
+
+  if (!res.length) return Result.error(new NotFoundError('Commit not found'))
+  const commit = res[0]!
+
+  if (commit.nextCommitId) return Result.ok(false)
+
+  const commitsReferencingCommit = await tx
+    .select({ id: commits.id })
+    .from(commits)
+    .where(eq(commits.nextCommitId, commit.id))
+
+  return Result.ok(commitsReferencingCommit.length === 0)
 }

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

@@ -1,23 +1,6 @@
 import { commits, database, documentVersions } from '@latitude-data/core'
 import { desc, eq, inArray, lte } from 'drizzle-orm'
 
-import { listStagedCommits } from './commits'
-
-export async function listStagedDocuments() {
-  const commits = await listStagedCommits()
-  if (!commits.length) return []
-
-  return database
-    .select()
-    .from(documentVersions)
-    .where(
-      inArray(
-        documentVersions.commitId,
-        commits.map((c) => c.id),
-      ),
-    )
-}
-
 export async function getDocumentsAtCommit(commitUuid: string) {
   const referenceCommitId = await database
     .select({ id: commits.id })

packages/core/src/schema/models/commits.ts

@@ -44,7 +44,10 @@ export const commits = latitudeSchema.table(
 
 export const commitRelations = relations(commits, ({ one, many }) => ({
   snapshots: many(documentSnapshots, { relationName: 'snapshots' }),
-  workspace: one(workspaces),
+  workspace: one(workspaces, {
+    fields: [commits.workspaceId],
+    references: [workspaces.id],
+  }),
 }))
 
 export type Commit = InferSelectModel<typeof commits> & {

packages/core/src/services/documentVersions/materializeAtCommit.ts

@@ -1,28 +1,20 @@
-import { uniqBy } from 'lodash-es'
-
 import {
   getDocumentsAtCommit,
   listdocumentSnapshots,
-  listStagedDocuments,
 } from '@latitude-data/core'
 
 export const HEAD_COMMIT = 'HEAD'
 
 export async function materializeDocumentsAtCommit({
   commitUuid = HEAD_COMMIT,
-  staged = true,
 }: {
   commitUuid: string
-  staged: boolean
 }) {
   if (commitUuid === HEAD_COMMIT) {
     const snapshots = (await listdocumentSnapshots()).map(
       (snap) => snap.document_versions,
     )
-    if (!staged) return snapshots
-
-    const versions = await listStagedDocuments()
-    return uniqBy([...versions, ...snapshots], (doc) => doc.documentUuid)
+    return snapshots
   } else {
     return await getDocumentsAtCommit(commitUuid)
   }