feat(chrono): checkout use-case

Author: zzhenryquezz

packages/chrono/playground/PlayApp.ts

@@ -44,6 +44,10 @@ async function run() {
             name: 'list',
             method: 'list',
         },
+        {
+            name: 'checkout',
+            method: 'checkout',
+        },
     ]
 
     const command = options.find((o) => o.name === commandName)

packages/chrono/src/ChronoApp.ts

@@ -19,6 +19,7 @@ import CommitUseCase from './use-cases/CommitUseCase'
 import StatusUseCase from './use-cases/StatusUseCase'
 import AddUseCase from './use-cases/AddUseCase'
 import ListFilesUseCase from './use-cases/ListFilesUseCase'
+import CheckoutUseCase from './use-cases/CheckoutUseCase'
 
 export default class ChronoApp {
     private readonly drive: IDrive
@@ -106,4 +107,10 @@ export default class ChronoApp {
 
         return useCase.execute()
     }
+
+    public async checkout(path: string, hash: string) {
+        const useCase = new CheckoutUseCase(this.drive, this.objectRepository, this.blobRepository)
+
+        return useCase.execute({ hash, path })
+    }
 }

packages/chrono/src/repositories/implementations/LocalHeadEntryRepository.ts

@@ -1,40 +1,19 @@
-import ChronoObjectTree from '../../entities/ChronoObjectTree'
 import HeadEntry from '../../entities/HeadEntry'
 import IDrive from '../../gateways/IDrive'
 import HelperService from '../../services/HelperService'
+import TreeService from '../../services/TreeService'
 import IHeadEntryRepository from '../IHeadEntryRepository'
 import IObjectRepository from '../IObjectRepository'
 
 export default class LocalHeadEntryRepository implements IHeadEntryRepository {
-    constructor(
-        private readonly drive: IDrive,
-        private readonly objectRepository: IObjectRepository
-    ) {}
-
-    public async findEntriesFromTree(treeHash: string, basePath = '') {
-        const entries = [] as HeadEntry[]
-
-        const object = await this.objectRepository.findOrFail(treeHash)
-
-        const tree = new ChronoObjectTree(object.content)
-
-        for await (const e of tree.entries) {
-            const headEntry = HeadEntry.from({
-                path: `${basePath}${e.path}`,
-                hash: e.hash,
-                type: e.type,
-            })
-
-            entries.push(headEntry)
-
-            if (e.type === 'tree') {
-                const childEntries = await this.findEntriesFromTree(e.hash, `${headEntry.path}/`)
-
-                entries.push(...childEntries)
-            }
-        }
-
-        return entries
+    private readonly drive: IDrive
+    private readonly objectRepository: IObjectRepository
+    private readonly treeService: TreeService
+
+    constructor(drive: IDrive, objectRepository: IObjectRepository) {
+        this.drive = drive
+        this.objectRepository = objectRepository
+        this.treeService = new TreeService(objectRepository)
     }
 
     public findAll: IHeadEntryRepository['findAll'] = async () => {
@@ -49,7 +28,15 @@ export default class LocalHeadEntryRepository implements IHeadEntryRepository {
         const object = await this.objectRepository.findOrFail(hash)
 
         if (object.type === 'commit') {
-            return this.findEntriesFromTree(object.head.tree)
+            const entries = await this.treeService.findTreeIndex(object.head.tree)
+
+            return entries.map((entry) =>
+                HeadEntry.from({
+                    path: entry.fullPath,
+                    hash: entry.hash,
+                    type: entry.type as any,
+                })
+            )
         }
 
         return []

packages/chrono/src/services/TreeService.ts

@@ -0,0 +1,44 @@
+import ChronoObjectTree from '../entities/ChronoObjectTree'
+import IObjectRepository from '../repositories/IObjectRepository'
+
+interface TreeEntry {
+    path: string
+    fullPath: string
+    hash: string
+    type: string
+}
+
+export default class TreeService {
+    constructor(private readonly objectRepository: IObjectRepository) {}
+
+    private async findEntriesFromTree(treeHash: string, basePath = '') {
+        const entries = [] as TreeEntry[]
+
+        const object = await this.objectRepository.findOrFail(treeHash)
+
+        const tree = new ChronoObjectTree(object.content)
+
+        for await (const e of tree.entries) {
+            const entry: TreeEntry = {
+                path: e.path,
+                fullPath: `${basePath}${e.path}`,
+                hash: e.hash,
+                type: e.type,
+            }
+
+            entries.push(entry)
+
+            if (e.type === 'tree') {
+                const childEntries = await this.findEntriesFromTree(e.hash, `${entry.path}/`)
+
+                entries.push(...childEntries)
+            }
+        }
+
+        return entries
+    }
+
+    public async findTreeIndex(hash: string) {
+        return this.findEntriesFromTree(hash)
+    }
+}

packages/chrono/src/use-cases/CheckoutUseCase.ts

@@ -0,0 +1,42 @@
+import IDrive from '../gateways/IDrive'
+import IBlobRepository from '../repositories/IBlobRepository'
+import IObjectRepository from '../repositories/IObjectRepository'
+import TreeService from '../services/TreeService'
+
+interface Params {
+    path: string
+    hash: string
+}
+
+export default class CheckoutUseCase {
+    constructor(
+        private readonly drive: IDrive,
+        private readonly objectRepository: IObjectRepository,
+        private readonly blobRepository: IBlobRepository
+    ) {}
+
+    public async execute({ path, hash }: Params) {
+        const service = new TreeService(this.objectRepository)
+        const object = await this.objectRepository.findOrFail(hash)
+
+        if (object.type !== 'commit') {
+            throw new Error('Object is not a commit')
+        }
+
+        const treeIndexEntries = await service.findTreeIndex(object.head.tree)
+
+        const treeEntry = treeIndexEntries.find((entry) => entry.fullPath === path)
+
+        if (!treeEntry) return
+
+        const blobObject = await this.objectRepository.findOrFail(treeEntry.hash)
+
+        if (blobObject.type !== 'blob') {
+            throw new Error('Error looking for blob object')
+        }
+
+        const contents = await this.blobRepository.findOrFail(blobObject.head.blobHash)
+
+        await this.drive.write(path, contents)
+    }
+}