refactor(chrono): rename Entry to IndexEntry

Author: zzhenryquezz

packages/chrono/src/ChronoApp.ts

@@ -3,48 +3,33 @@ import IHash from './gateways/IHash'
 
 import IBlobRepository from './repositories/IBlobRepository'
 import IObjectRepository from './repositories/IObjectRepository'
-import IStageItemRepository from './repositories/IStageItemRepository'
 
 import LocalObjectRepository from './repositories/implementations/LocalObjectRepository'
 import LocalBlobRepository from './repositories/implementations/LocalBlobRepository'
-import LocalStageItemRepository from './repositories/implementations/LocalStageItemRepository'
 
 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 IEntryRepository from './repositories/IEntryRepository'
+import IIndexEntryRepository from './repositories/IIndexEntryRepository'
 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
+    private readonly entryRepository: IIndexEntryRepository
 
     constructor(
         private readonly drive: IDrive,
         private readonly hash: IHash
     ) {
         this.objectRepository = new LocalObjectRepository(drive, hash)
         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
-        )
+        this.entryRepository = new LocalEntryRepository(drive)
     }
 
     public async init() {
@@ -100,7 +85,12 @@ export default class ChronoApp {
     }
 
     public async status() {
-        const useCase = new StatusUseCase(this.drive, this.entryRepository)
+        const useCase = new StatusUseCase(
+            this.drive,
+            this.objectRepository,
+            this.blobRepository,
+            this.entryRepository
+        )
 
         return useCase.execute()
     }

packages/chrono/src/entities/ChronoEntry.ts

@@ -45,7 +45,7 @@ export default class ChronoObject {
         }
     }
 
-    public static from(object: Record<string, any>, body?: string) {
+    public static fromObject(object: Record<string, any>, body?: string) {
         let content = ''
 
         Object.entries(object).forEach(([key, value]) => {

packages/chrono/src/entities/ChronoObject.ts

@@ -0,0 +1,43 @@
+import ChronoObject from './ChronoObject'
+
+interface Payload {
+    message: string
+    tree: string
+    parent?: string
+    body?: string
+}
+
+export default class ChronoObjectCommit extends ChronoObject {
+    public get message() {
+        return this.head.message
+    }
+
+    public get tree() {
+        return this.head.tree
+    }
+
+    public get parent() {
+        return this.head.parent
+    }
+
+    public static from(payload: Payload) {
+        const object = ChronoObject.fromObject(
+            {
+                type: 'commit',
+                message: payload.message,
+                tree: payload.tree,
+                parent: payload.parent,
+            },
+            payload.body
+        )
+
+        return new ChronoObjectCommit(object.content)
+    }
+
+    public serialize() {
+        return {
+            ...super.serialize(),
+            message: this.message,
+        }
+    }
+}

packages/chrono/src/entities/ChronoObjectCommit.ts

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

packages/chrono/src/entities/IndexEntry.ts

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

packages/chrono/src/repositories/IEntryRepository.ts

@@ -1,24 +1,22 @@
-import ChronoEntry from '../../entities/ChronoEntry'
+import IndexEntry from '../../entities/IndexEntry'
 import IDrive from '../../gateways/IDrive'
-import IHash from '../../gateways/IHash'
 import HelperService from '../../services/HelperService'
-import IEntryRepository from '../IEntryRepository'
+import IIndexEntryRepository from '../IIndexEntryRepository'
 
-export default class LocalEntryRepository implements IEntryRepository {
-    constructor(
-        private readonly drive: IDrive,
-        private readonly hash: IHash
-    ) {}
+export default class LocalEntryRepository implements IIndexEntryRepository {
+    constructor(private readonly drive: IDrive) {}
 
-    public findAll: IEntryRepository['findAll'] = async () => {
+    public findAll: IIndexEntryRepository['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))
+        const entries = json.map((i: any) => new IndexEntry(i.path, i.hash, i.status))
+
+        return entries
     }
 
-    public saveAll: IEntryRepository['saveAll'] = async (entries) => {
+    public saveAll: IIndexEntryRepository['saveAll'] = async (entries) => {
         await this.drive.write(
             '.chrono/index',
             HelperService.encode(JSON.stringify(entries, null, 4))

packages/chrono/src/repositories/IIndexEntryRepository.ts

@@ -21,7 +21,7 @@ export default class HashEntryService {
 
         const { blobHash } = await this.blobRepository.save(content)
 
-        const blobObject = ChronoObject.from({
+        const blobObject = ChronoObject.fromObject({
             type: 'blob',
             blobHash,
         })

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

@@ -1,8 +1,8 @@
-import ChronoEntry from '../entities/ChronoEntry'
+import IndexEntry from '../entities/IndexEntry'
 import IDrive from '../gateways/IDrive'
 
 import IBlobRepository from '../repositories/IBlobRepository'
-import IEntryRepository from '../repositories/IEntryRepository'
+import IIndexEntryRepository from '../repositories/IIndexEntryRepository'
 import IObjectRepository from '../repositories/IObjectRepository'
 
 import HashEntryService from '../services/HashEntryService'
@@ -16,7 +16,7 @@ export default class AddUseCase {
         private readonly drive: IDrive,
         private readonly objectRepository: IObjectRepository,
         private readonly blobRepository: IBlobRepository,
-        private readonly entryRepository: IEntryRepository
+        private readonly entryRepository: IIndexEntryRepository
     ) {}
 
     public async addEntry(path: string) {
@@ -31,11 +31,25 @@ export default class AddUseCase {
 
         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)
+        if (entry && entry.hash === objectHash) {
+            entry.status = IndexEntry.STATUS.Unmodified
+
+            await this.entryRepository.saveAll(entries)
+
+            return entry
+        }
+
+        if (entry) {
+            entry.status = IndexEntry.STATUS.Added
+
+            await this.entryRepository.saveAll(entries)
+
+            return entry
+        }
+
+        const newEntry = new IndexEntry(path, objectHash, IndexEntry.STATUS.Added)
 
         entries.push(newEntry)
 
@@ -45,7 +59,7 @@ export default class AddUseCase {
     }
 
     public async execute({ path }: Params) {
-        const result = [] as ChronoEntry[]
+        const result = [] as IndexEntry[]
 
         if (await this.drive.isFile(path)) {
             const entry = await this.addEntry(path)

packages/chrono/src/services/HashEntryService.ts

@@ -17,7 +17,7 @@ describe('CatFileUseCase', () => {
         await drive.write('message.md', HelperService.encode('Hello World!'))
 
         const { objectHash } = await objectRepository.save(
-            ChronoObject.from({
+            ChronoObject.fromObject({
                 type: 'blob',
                 blobHash: '123',
             })