feat(chrono): add head entry repository

Author: zzhenryquezz

packages/chrono/src/ChronoApp.ts

@@ -3,33 +3,40 @@ import IHash from './gateways/IHash'
 
 import IBlobRepository from './repositories/IBlobRepository'
 import IObjectRepository from './repositories/IObjectRepository'
+import IIndexEntryRepository from './repositories/IIndexEntryRepository'
+import IHeadEntryRepository from './repositories/IHeadEntryRepository'
 
 import LocalObjectRepository from './repositories/implementations/LocalObjectRepository'
 import LocalBlobRepository from './repositories/implementations/LocalBlobRepository'
+import LocalIndexEntryRepository from './repositories/implementations/LocalIndexEntryRepository'
+import LocalHeadEntryRepository from './repositories/implementations/LocalHeadEntryRepository'
 
 import InitUseCase from './use-cases/InitUseCase'
 import CatFileUseCase from './use-cases/CatFileUseCase'
 import HashFileUseCase from './use-cases/HashEntryUseCase'
 import RemoveUseCase from './use-cases/RemoveUseCase'
 import CommitUseCase from './use-cases/CommitUseCase'
 import StatusUseCase from './use-cases/StatusUseCase'
-import IIndexEntryRepository from './repositories/IIndexEntryRepository'
-import LocalEntryRepository from './repositories/implementations/LocalEntryRepository'
 import AddUseCase from './use-cases/AddUseCase'
 import ListFilesUseCase from './use-cases/ListFilesUseCase'
 
 export default class ChronoApp {
+    private readonly drive: IDrive
+    private readonly hash: IHash
+
     private readonly objectRepository: IObjectRepository
     private readonly blobRepository: IBlobRepository
-    private readonly entryRepository: IIndexEntryRepository
+    private readonly indexEntryRepository: IIndexEntryRepository
+    private readonly headEntryRepository: IHeadEntryRepository
+
+    constructor(drive: IDrive, hash: IHash) {
+        this.drive = drive
+        this.hash = hash
 
-    constructor(
-        private readonly drive: IDrive,
-        private readonly hash: IHash
-    ) {
         this.objectRepository = new LocalObjectRepository(drive, hash)
         this.blobRepository = new LocalBlobRepository(drive, hash)
-        this.entryRepository = new LocalEntryRepository(drive)
+        this.indexEntryRepository = new LocalIndexEntryRepository(drive)
+        this.headEntryRepository = new LocalHeadEntryRepository(drive, this.objectRepository)
     }
 
     public async init() {
@@ -50,35 +57,35 @@ export default class ChronoApp {
         return useCase.execute({ objectHash })
     }
 
-    public async addEntry(path: string) {
+    public async addEntry(...path: string[]) {
         const useCase = new AddUseCase(
             this.drive,
             this.objectRepository,
             this.blobRepository,
-            this.entryRepository
+            this.indexEntryRepository
         )
 
         return useCase.execute({ path })
     }
 
     public async removeEntry(path: string) {
-        const useCase = new RemoveUseCase(this.drive, this.entryRepository)
+        const useCase = new RemoveUseCase(this.drive, this.indexEntryRepository)
 
         return useCase.execute({ path })
     }
 
-    public async list() {
-        const useCase = new ListFilesUseCase(this.entryRepository)
+    public async list(stage = false) {
+        const useCase = new ListFilesUseCase(this.indexEntryRepository, this.headEntryRepository)
 
-        return useCase.execute()
+        return useCase.execute({ stage })
     }
 
     public async commit(message: string, body?: string) {
         const useCase = new CommitUseCase(
             this.drive,
             this.objectRepository,
             this.blobRepository,
-            this.entryRepository
+            this.indexEntryRepository
         )
 
         return useCase.execute({ message, body })
@@ -89,7 +96,7 @@ export default class ChronoApp {
             this.drive,
             this.objectRepository,
             this.blobRepository,
-            this.entryRepository
+            this.indexEntryRepository
         )
 
         return useCase.execute()

packages/chrono/src/entities/ChronoObjectTree.ts

@@ -3,7 +3,7 @@ import ChronoObject from './ChronoObject'
 export interface ChronoObjectTreeEntry {
     path: string
     hash: string
-    type: string
+    type: 'blob' | 'tree'
 }
 
 export default class ChronoObjectTree extends ChronoObject {
@@ -17,7 +17,7 @@ export default class ChronoObjectTree extends ChronoObject {
                 type,
                 hash,
                 path,
-            }
+            } as ChronoObjectTreeEntry
         })
     }
 

packages/chrono/src/entities/HeadEntry.ts

@@ -0,0 +1,13 @@
+export default class HeadEntry {
+    public path: string
+    public hash: string
+    public type: 'blob' | 'tree' = 'blob'
+
+    public static from(payload: Pick<HeadEntry, 'path' | 'hash' | 'type'>) {
+        const head = new HeadEntry()
+
+        Object.assign(head, payload)
+
+        return head
+    }
+}

packages/chrono/src/repositories/IHeadEntryRepository.ts

@@ -0,0 +1,5 @@
+import HeadEntry from '../entities/HeadEntry'
+
+export default interface IHeadEntryRepository {
+    findAll(): Promise<HeadEntry[]>
+}

packages/chrono/src/repositories/IStageItemRepository.ts

@@ -0,0 +1,57 @@
+import ChronoObjectTree from '../../entities/ChronoObjectTree'
+import HeadEntry from '../../entities/HeadEntry'
+import IDrive from '../../gateways/IDrive'
+import HelperService from '../../services/HelperService'
+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
+    }
+
+    public findAll: IHeadEntryRepository['findAll'] = async () => {
+        const contents = await this.drive.read('.chrono/head')
+
+        const hash = HelperService.decode(contents)
+
+        if (!hash) {
+            return []
+        }
+
+        const object = await this.objectRepository.findOrFail(hash)
+
+        if (object.type === 'commit') {
+            return this.findEntriesFromTree(object.head.tree)
+        }
+
+        return []
+    }
+}

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

@@ -3,7 +3,7 @@ import IDrive from '../../gateways/IDrive'
 import HelperService from '../../services/HelperService'
 import IIndexEntryRepository from '../IIndexEntryRepository'
 
-export default class LocalEntryRepository implements IIndexEntryRepository {
+export default class LocalIndexEntryRepository implements IIndexEntryRepository {
     constructor(private readonly drive: IDrive) {}
 
     public findAll: IIndexEntryRepository['findAll'] = async () => {

packages/chrono/src/repositories/implementations/LocalEntryRepository.ts renamed to packages/chrono/src/repositories/implementations/LocalIndexEntryRepository.ts

@@ -1,9 +1,18 @@
 export default class HelperService {
+    public static basename(path: string) {
+        const parts = path.split('/')
+
+        return parts[parts.length - 1]
+    }
+
     public static encode(content: string) {
         return new TextEncoder().encode(content)
     }
 
-    public static decode(content: Uint8Array) {
+    public static decode(content?: Uint8Array | null) {
+        if (!content) {
+            return ''
+        }
         return new TextDecoder('utf-8').decode(content)
     }
 }

packages/chrono/src/services/HelperService.ts

@@ -1,9 +1,20 @@
+import IHeadEntryRepository from '../repositories/IHeadEntryRepository'
 import IIndexEntryRepository from '../repositories/IIndexEntryRepository'
 
+interface Params {
+    stage: boolean
+}
 export default class ListFilesUseCase {
-    constructor(private readonly entryRepository: IIndexEntryRepository) {}
+    constructor(
+        private readonly indexEntryRepository: IIndexEntryRepository,
+        private readonly headEntryRepository: IHeadEntryRepository
+    ) {}
+
+    async execute({ stage }: Params) {
+        if (stage) {
+            return this.indexEntryRepository.findAll()
+        }
 
-    async execute() {
-        return this.entryRepository.findAll()
+        return this.headEntryRepository.findAll()
     }
 }