refactor(chrono)!: remake stage area workflow

Author: zzhenryquezz

packages/chrono/playground/PlayApp.ts

@@ -36,6 +36,14 @@ async function run() {
             name: 'commit',
             method: 'commit',
         },
+        {
+            name: 'status',
+            method: 'status',
+        },
+        {
+            name: 'list',
+            method: 'list',
+        },
     ]
 
     const command = options.find((o) => o.name === commandName)

packages/chrono/src/ChronoApp.ts

@@ -11,16 +11,24 @@ import LocalStageItemRepository from './repositories/implementations/LocalStageI
 
 import InitUseCase from './use-cases/InitUseCase'
 import CatFileUseCase from './use-cases/CatFileUseCase'
-import HashFileUseCase from './use-cases/HashFileUseCase'
-import RemoveStageItemUseCase from './use-cases/RemoveStageItemUseCase'
-import AddStageItemUseCase from './use-cases/AddStageItemUseCase'
+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 IEntryRepository from './repositories/IEntryRepository'
+import LocalEntryRepository from './repositories/implementations/LocalEntryRepository'
+import AddUseCase from './use-cases/AddUseCase'
+import ListFilesUseCase from './use-cases/ListFilesUseCase'
+import HashEntryService from './services/HashEntryService'
 
 export default class ChronoApp {
     private readonly objectRepository: IObjectRepository
     private readonly blobRepository: IBlobRepository
 
     private readonly stageItemRepository: IStageItemRepository
+    private readonly entryRepository: IEntryRepository
+
+    private readonly hashEntryService: HashEntryService
 
     constructor(
         private readonly drive: IDrive,
@@ -30,6 +38,13 @@ export default class ChronoApp {
         this.blobRepository = new LocalBlobRepository(drive, hash)
 
         this.stageItemRepository = new LocalStageItemRepository(drive)
+        this.entryRepository = new LocalEntryRepository(drive, hash)
+
+        this.hashEntryService = new HashEntryService(
+            drive,
+            this.objectRepository,
+            this.blobRepository
+        )
     }
 
     public async init() {
@@ -51,30 +66,42 @@ export default class ChronoApp {
     }
 
     public async addEntry(path: string) {
-        const useCase = new AddStageItemUseCase(
+        const useCase = new AddUseCase(
             this.drive,
-            this.stageItemRepository,
             this.objectRepository,
-            this.blobRepository
+            this.blobRepository,
+            this.entryRepository
         )
 
         return useCase.execute({ path })
     }
 
     public async removeEntry(path: string) {
-        const useCase = new RemoveStageItemUseCase(this.stageItemRepository)
+        const useCase = new RemoveUseCase(this.drive, this.entryRepository)
 
         return useCase.execute({ path })
     }
 
+    public async list() {
+        const useCase = new ListFilesUseCase(this.entryRepository)
+
+        return useCase.execute()
+    }
+
     public async commit(message: string, body?: string) {
         const useCase = new CommitUseCase(
             this.drive,
             this.objectRepository,
             this.blobRepository,
-            this.stageItemRepository
+            this.entryRepository
         )
 
         return useCase.execute({ message, body })
     }
+
+    public async status() {
+        const useCase = new StatusUseCase(this.drive, this.entryRepository)
+
+        return useCase.execute()
+    }
 }

packages/chrono/src/entities/ChronoEntry.ts

@@ -0,0 +1,30 @@
+export enum ChronoEntryStatus {
+    Unmodified = 0,
+    Modified = 1,
+    Added = 2,
+    Deleted = 3,
+    Renamed = 4,
+    Copied = 5,
+}
+
+export default class ChronoEntry {
+    public path: string
+    public hash: string
+    public status: ChronoEntryStatus
+
+    public static STATUS = ChronoEntryStatus
+
+    constructor(
+        path: string,
+        hash: string,
+        status: ChronoEntryStatus = ChronoEntryStatus.Unmodified
+    ) {
+        this.path = path
+        this.hash = hash
+        this.status = status
+    }
+
+    public static from({ path, hash, status }: Pick<ChronoEntry, 'path' | 'hash' | 'status'>) {
+        return new ChronoEntry(path, hash, status)
+    }
+}

packages/chrono/src/repositories/IEntryRepository.ts

@@ -0,0 +1,6 @@
+import ChronoEntry from '../entities/ChronoEntry'
+
+export default interface IEntryRepository {
+    findAll(): Promise<ChronoEntry[]>
+    saveAll(entries: ChronoEntry[]): Promise<void>
+}

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

@@ -0,0 +1,27 @@
+import ChronoEntry from '../../entities/ChronoEntry'
+import IDrive from '../../gateways/IDrive'
+import IHash from '../../gateways/IHash'
+import HelperService from '../../services/HelperService'
+import IEntryRepository from '../IEntryRepository'
+
+export default class LocalEntryRepository implements IEntryRepository {
+    constructor(
+        private readonly drive: IDrive,
+        private readonly hash: IHash
+    ) {}
+
+    public findAll: IEntryRepository['findAll'] = async () => {
+        const contents = await this.drive.read('.chrono/index')
+
+        const json = JSON.parse(contents ? HelperService.decode(contents) : '[]')
+
+        return json.map((i: any) => new ChronoEntry(i.path, i.hash, i.status))
+    }
+
+    public saveAll: IEntryRepository['saveAll'] = async (entries) => {
+        await this.drive.write(
+            '.chrono/index',
+            HelperService.encode(JSON.stringify(entries, null, 4))
+        )
+    }
+}

packages/chrono/src/use-cases/AddStageItemUseCase.spec.ts

@@ -0,0 +1,71 @@
+import ChronoEntry from '../entities/ChronoEntry'
+import IDrive from '../gateways/IDrive'
+
+import IBlobRepository from '../repositories/IBlobRepository'
+import IEntryRepository from '../repositories/IEntryRepository'
+import IObjectRepository from '../repositories/IObjectRepository'
+
+import HashEntryService from '../services/HashEntryService'
+
+interface Params {
+    path: string
+}
+
+export default class AddUseCase {
+    constructor(
+        private readonly drive: IDrive,
+        private readonly objectRepository: IObjectRepository,
+        private readonly blobRepository: IBlobRepository,
+        private readonly entryRepository: IEntryRepository
+    ) {}
+
+    public async addEntry(path: string) {
+        const hashService = new HashEntryService(
+            this.drive,
+            this.objectRepository,
+            this.blobRepository
+        )
+
+        // list all workspace entries
+        const entries = await this.entryRepository.findAll()
+
+        const entry = entries.find((entry) => entry.path === path)
+
+        if (entry) return entry
+
+        const { objectHash } = await hashService.hashEntry(path)
+
+        const newEntry = new ChronoEntry(path, objectHash, ChronoEntry.STATUS.Added)
+
+        entries.push(newEntry)
+
+        await this.entryRepository.saveAll(entries)
+
+        return newEntry
+    }
+
+    public async execute({ path }: Params) {
+        const result = [] as ChronoEntry[]
+
+        if (await this.drive.isFile(path)) {
+            const entry = await this.addEntry(path)
+
+            result.push(entry)
+
+            return result
+        }
+
+        const files = await this.drive.readdir(path, {
+            recursive: true,
+            onlyFiles: true,
+        })
+
+        for await (const file of files) {
+            const entry = await this.addEntry(`${path}/${file}`)
+
+            result.push(entry)
+        }
+
+        return result
+    }
+}

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

@@ -18,6 +18,6 @@ export default class InitUseCase {
         await this.drive.mkdir('.chrono/stage')
 
         await this.drive.write('.chrono/head', HelperService.encode(''))
-        await this.drive.write('.chrono/stage/index', HelperService.encode(''))
+        await this.drive.write('.chrono/index', HelperService.encode('[]'))
     }
 }