feat(chrono): add to stage use-case

Author: zzhenryquezz

packages/chrono/playground/PlayApp.ts

@@ -21,6 +21,10 @@ async function run() {
     if (command === 'cat') {
         console.log(await app.catFile(process.argv[3]))
     }
+
+    if (command === 'add') {
+        console.log(await app.add(process.argv[3]))
+    }
 }
 
 run()

packages/chrono/src/ChronoApp.ts

@@ -7,6 +7,9 @@ import LocalObjectRepository from './repositories/implementations/LocalObjectRep
 import CatFileUseCase from './use-cases/CatFileUseCase'
 import HashFileUseCase from './use-cases/HashFileUseCase'
 import InitUseCase from './use-cases/InitUseCase'
+import AddFileToStagedUseCase from './use-cases/AddFileToStagedUseCase'
+import LocalStageItemRepository from './repositories/implementations/LocalStageItemRepository'
+import IStageItemRepository from './repositories/IStageItemRepository'
 
 export default class ChronoApp {
     private readonly objectRepository: IObjectRepository
@@ -15,6 +18,8 @@ export default class ChronoApp {
     private readonly objectTemporaryRepository: IObjectRepository
     private readonly blobTemporaryRepository: IBlobRepository
 
+    private readonly stageItemRepository: IStageItemRepository
+
     constructor(
         private readonly drive: IDrive,
         private readonly hash: IHash
@@ -29,6 +34,8 @@ export default class ChronoApp {
         )
 
         this.blobTemporaryRepository = new LocalBlobRepository(drive, hash, '.chrono/tmp/blobs')
+
+        this.stageItemRepository = new LocalStageItemRepository(drive)
     }
 
     public async init() {
@@ -52,4 +59,15 @@ export default class ChronoApp {
 
         return useCase.execute({ objectHash })
     }
+
+    public async add(path: string) {
+        const useCase = new AddFileToStagedUseCase(
+            this.drive,
+            this.stageItemRepository,
+            this.objectTemporaryRepository,
+            this.blobTemporaryRepository
+        )
+
+        return useCase.execute({ path })
+    }
 }

packages/chrono/src/entities/ChronoStageItem.ts

@@ -0,0 +1,15 @@
+export default class ChronoStageItem {
+    public type: string
+    public path: string
+    public hash: string
+
+    public static from({ type, path, hash }: ChronoStageItem) {
+        const item = new ChronoStageItem()
+
+        item.type = type
+        item.path = path
+        item.hash = hash
+
+        return item
+    }
+}

packages/chrono/src/exceptions/BaseException.ts

@@ -1,5 +1,5 @@
 export default class BaseException extends Error {
-    constructor(message: string, data?: any) {
+    constructor(message = 'Some error happen', data?: any) {
         super(message)
 
         this.message = message

packages/chrono/src/repositories/IObjectRepository.ts

@@ -1,7 +1,6 @@
 import ChronoObject from '../entities/ChronoObject'
 
 export default interface IObjectRepository {
-    // exists(objectHash: string): Promise<boolean>
-    find(objectHash: string): Promise<any>
+    find(objectHash: string): Promise<ChronoObject | null>
     save(object: ChronoObject): Promise<{ objectHash: string }>
 }

packages/chrono/src/repositories/IStageItemRepository.ts

@@ -0,0 +1,6 @@
+import ChronoStageItem from '../entities/ChronoStageItem'
+
+export default interface IStageItemRepository {
+    save(item: ChronoStageItem): Promise<void>
+    findAll(): Promise<ChronoStageItem[]>
+}

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

@@ -1,5 +1,4 @@
 import ChronoObject from '../../entities/ChronoObject'
-import ChronoObjectTree from '../../entities/ChronoObjectTree'
 import IDrive from '../../gateways/IDrive'
 import IHash from '../../gateways/IHash'
 import IObjectRepository from '../IObjectRepository'
@@ -11,7 +10,7 @@ export default class LocalObjectRepository implements IObjectRepository {
         private readonly directory = '.chrono/objects'
     ) {}
 
-    public async save(chronoObject: ChronoObject) {
+    public save: IObjectRepository['save'] = async (chronoObject) => {
         const objectHash = await this.hash.hash(chronoObject.toBytes())
 
         const startHash = objectHash.slice(0, 2)
@@ -31,7 +30,7 @@ export default class LocalObjectRepository implements IObjectRepository {
         }
     }
 
-    public async find(objectHash: string) {
+    public find: IObjectRepository['find'] = async (objectHash) => {
         const startHash = objectHash.slice(0, 2)
         const endHash = objectHash.slice(2)
 
@@ -59,10 +58,6 @@ export default class LocalObjectRepository implements IObjectRepository {
 
         const chronoObject = new ChronoObject(bytes)
 
-        if (chronoObject.type === 'tree') {
-            return new ChronoObjectTree(bytes)
-        }
-
         return chronoObject
     }
 }

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

@@ -0,0 +1,53 @@
+import ChronoStageItem from '../../entities/ChronoStageItem'
+import IDrive from '../../gateways/IDrive'
+import HelperService from '../../services/HelperService'
+import IStageItemRepository from '../IStageItemRepository'
+
+export default class LocalStageItemRepository implements IStageItemRepository {
+    constructor(
+        private readonly drive: IDrive,
+        private readonly filename = '.chrono/tmp/stage'
+    ) {}
+
+    public save: IStageItemRepository['save'] = async (item) => {
+        const all = await this.findAll()
+
+        const search = all.find((i) => i.path === item.path)
+
+        if (!search) {
+            all.push(item)
+        }
+
+        if (search) {
+            search.hash = item.hash
+        }
+
+        const content = all.map((i) => `${i.type} ${i.hash} ${i.path}`).join('\n')
+
+        await this.drive.write(this.filename, HelperService.encode(content))
+    }
+
+    public findAll: IStageItemRepository['findAll'] = async () => {
+        const bytes = await this.drive.read(this.filename)
+
+        const items = [] as ChronoStageItem[]
+
+        if (bytes) {
+            const content = HelperService.decode(bytes)
+
+            for (const line of content.split('\n')) {
+                const [type, hash, path] = line.split(' ')
+
+                items.push(
+                    ChronoStageItem.from({
+                        type,
+                        hash,
+                        path,
+                    })
+                )
+            }
+        }
+
+        return items
+    }
+}

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

@@ -1,15 +1,91 @@
+import ChronoObjectTree from '../entities/ChronoObjectTree'
+import ChronoStageItem from '../entities/ChronoStageItem'
+import BaseException from '../exceptions/BaseException'
 import IDrive from '../gateways/IDrive'
+import IBlobRepository from '../repositories/IBlobRepository'
+import IObjectRepository from '../repositories/IObjectRepository'
+import IStageItemRepository from '../repositories/IStageItemRepository'
+import HashFileUseCase from './HashFileUseCase'
 
 interface Params {
     path: string
 }
 
 export default class AddFileToStagedUseCase {
-    constructor(private readonly drive: IDrive) {}
+    private hashFileUseCase: HashFileUseCase
+
+    constructor(
+        private readonly drive: IDrive,
+        private readonly stageItemRepository: IStageItemRepository,
+        private readonly objectRepository: IObjectRepository,
+        private readonly blobRepository: IBlobRepository
+    ) {
+        this.hashFileUseCase = new HashFileUseCase(drive, objectRepository, blobRepository)
+    }
+
+    public async findAllTreeStageItem(rootPath: string) {
+        const items = [] as ChronoStageItem[]
+
+        const { objectHash: rootHash } = await this.hashFileUseCase.execute({ path: rootPath })
+
+        const tree = (await this.objectRepository.find(rootHash)) as ChronoObjectTree
+
+        if (!tree || tree.type !== 'tree') {
+            throw new BaseException()
+        }
+
+        items.push(ChronoStageItem.from({ type: 'tree', hash: rootHash, path: rootPath }))
+
+        for (const entry of tree.entries) {
+            const entryPath = `${rootPath}/${entry.name}`
+
+            if (entry.type === 'blob') {
+                const { objectHash } = await this.hashFileUseCase.execute({ path: entryPath })
+
+                items.push(
+                    ChronoStageItem.from({ type: 'blob', hash: objectHash, path: entryPath })
+                )
+            }
+
+            if (entry.type === 'tree') {
+                const subItems = await this.findAllTreeStageItem(entryPath)
+
+                items.push(...subItems)
+            }
+        }
+
+        return items
+    }
 
     async execute({ path }: Params) {
-        return path
-        // create a staged object
-        // use repository to save it
+        const { objectHash } = await this.hashFileUseCase.execute({ path })
+
+        const chronoObject = await this.objectRepository.find(objectHash)
+
+        if (!chronoObject) {
+            throw new BaseException()
+        }
+
+        if (chronoObject.type === 'blob') {
+            const item = ChronoStageItem.from({
+                type: 'blob',
+                hash: objectHash,
+                path,
+            })
+
+            await this.stageItemRepository.save(item)
+
+            return item
+        }
+
+        if (chronoObject.type === 'tree') {
+            const items = await this.findAllTreeStageItem(path)
+
+            for (const item of items) {
+                await this.stageItemRepository.save(item)
+            }
+
+            return items
+        }
     }
 }