feat(chrono): commit use-case

Author: zzhenryquezz

packages/chrono/playground/PlayApp.ts

@@ -32,6 +32,10 @@ async function run() {
             name: 'remove',
             method: 'removeEntry',
         },
+        {
+            name: 'commit',
+            method: 'commit',
+        },
     ]
 
     const command = options.find((o) => o.name === commandName)

packages/chrono/src/ChronoApp.ts

@@ -14,6 +14,7 @@ import CatFileUseCase from './use-cases/CatFileUseCase'
 import HashFileUseCase from './use-cases/HashFileUseCase'
 import RemoveStageItemUseCase from './use-cases/RemoveStageItemUseCase'
 import AddStateItemUseCase from './use-cases/AddStageItemUseCase'
+import CommitUseCase from './use-cases/CommitUseCase'
 
 export default class ChronoApp {
     private readonly objectRepository: IObjectRepository
@@ -59,7 +60,7 @@ export default class ChronoApp {
     }
 
     public async catEntry(objectHash: string) {
-        const useCase = new CatFileUseCase(this.objectTemporaryRepository)
+        const useCase = new CatFileUseCase(this.objectRepository, this.objectTemporaryRepository)
 
         return useCase.execute({ objectHash })
     }
@@ -80,4 +81,16 @@ export default class ChronoApp {
 
         return useCase.execute({ path })
     }
+
+    public async commit(message: string, body?: string) {
+        const useCase = new CommitUseCase(
+            this.objectRepository,
+            this.objectTemporaryRepository,
+            this.blobRepository,
+            this.blobTemporaryRepository,
+            this.stageItemRepository
+        )
+
+        return useCase.execute({ message, body })
+    }
 }

packages/chrono/src/entities/ChronoObject.ts

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

packages/chrono/src/entities/ChronoObjectTree.ts

@@ -1,22 +1,22 @@
 import ChronoObject from './ChronoObject'
 
 export interface ChronoObjectTreeEntry {
-    name: string
+    path: string
     hash: string
-    type: 'blob' | 'tree'
+    type: string
 }
 
 export default class ChronoObjectTree extends ChronoObject {
     public get entries() {
         const lines = this.body.split('\n').filter(Boolean)
 
         return lines.map((line) => {
-            const [type, hash, name] = line.split(' ')
+            const [type, hash, path] = line.split(' ')
 
             return {
                 type,
                 hash,
-                name,
+                path,
             }
         })
     }
@@ -32,7 +32,7 @@ export default class ChronoObjectTree extends ChronoObject {
         let content = 'type: tree' + ChronoObject.HEAD_SEPARATOR
 
         entries.forEach((entry) => {
-            content += `${entry.type} ${entry.hash} ${entry.name}\n`
+            content += `${entry.type} ${entry.hash} ${entry.path}\n`
         })
 
         return new ChronoObjectTree(content)

packages/chrono/src/repositories/IBlobRepository.ts

@@ -1,4 +1,6 @@
 export default interface IBlobRepository {
     save(content: Uint8Array): Promise<{ blobHash: string }>
     find(blobHash: string): Promise<Uint8Array | null>
+    findOrFail(blobHash: string): Promise<Uint8Array>
+    copyFrom(source: IBlobRepository, blobHash: string): Promise<void>
 }

packages/chrono/src/repositories/IObjectRepository.ts

@@ -2,5 +2,7 @@ import ChronoObject from '../entities/ChronoObject'
 
 export default interface IObjectRepository {
     find(objectHash: string): Promise<ChronoObject | null>
+    findOrFail(objectHash: string): Promise<ChronoObject>
     save(object: ChronoObject): Promise<{ objectHash: string }>
+    copyFrom(repository: IObjectRepository, objectHash: string): Promise<void>
 }

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

@@ -46,4 +46,20 @@ export default class LocalBlobRepository implements IBlobRepository {
 
         return bytes
     }
+
+    public findOrFail: IBlobRepository['findOrFail'] = async (blobHash) => {
+        const bytes = await this.find(blobHash)
+
+        if (!bytes) {
+            throw new Error(`Blob ${blobHash} not found`)
+        }
+
+        return bytes
+    }
+
+    public copyFrom: IBlobRepository['copyFrom'] = async (repository, blobHash) => {
+        const bytes = await repository.findOrFail(blobHash)
+
+        await this.save(bytes)
+    }
 }

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

@@ -36,6 +36,10 @@ export default class LocalObjectRepository implements IObjectRepository {
 
         const folderPath = this.drive.resolve(this.directory, startHash)
 
+        if (!(await this.drive.exists(folderPath))) {
+            return null
+        }
+
         const files = await this.drive.readdir(folderPath)
 
         const search = files.find((file) => file.startsWith(endHash))
@@ -60,4 +64,20 @@ export default class LocalObjectRepository implements IObjectRepository {
 
         return chronoObject
     }
+
+    public findOrFail: IObjectRepository['findOrFail'] = async (objectHash) => {
+        const chronoObject = await this.find(objectHash)
+
+        if (!chronoObject) {
+            throw new Error(`Object ${objectHash} not found`)
+        }
+
+        return chronoObject
+    }
+
+    public copyFrom: IObjectRepository['copyFrom'] = async (repository, objectHash) => {
+        const chronoObject = await repository.findOrFail(objectHash)
+
+        await this.save(chronoObject)
+    }
 }

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

@@ -1,20 +1,27 @@
-import BaseException from '../exceptions/BaseException'
 import IObjectRepository from '../repositories/IObjectRepository'
 
 interface CatUseCaseParams {
     objectHash: string
 }
 
 export default class CatFileUseCase {
-    constructor(private readonly objectRepository: IObjectRepository) {}
+    constructor(
+        private readonly objectRepository: IObjectRepository,
+        private readonly objectTemporaryRepository: IObjectRepository
+    ) {}
 
     async execute({ objectHash }: CatUseCaseParams) {
-        const object = await this.objectRepository.find(objectHash)
+        let result = await this.objectRepository.find(objectHash)
+        let isTemporary = false
 
-        if (!object) {
-            throw new BaseException(`Object ${objectHash} not found`)
+        if (!result) {
+            result = await this.objectTemporaryRepository.find(objectHash)
+            isTemporary = !!result
         }
 
-        return object.serialize()
+        return {
+            isTemporary,
+            object: result?.serialize() ?? null,
+        }
     }
 }

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

@@ -0,0 +1,59 @@
+import ChronoObject from '../entities/ChronoObject'
+import ChronoObjectTree from '../entities/ChronoObjectTree'
+import IBlobRepository from '../repositories/IBlobRepository'
+import IObjectRepository from '../repositories/IObjectRepository'
+import IStageItemRepository from '../repositories/IStageItemRepository'
+import HashFileUseCase from './HashFileUseCase'
+
+interface Params {
+    message: string
+    body?: string
+}
+
+export default class CommitUseCase {
+    public hashFileUseCase: HashFileUseCase
+
+    constructor(
+        private readonly objectRepository: IObjectRepository,
+        private readonly objectTemporaryRepository: IObjectRepository,
+        private readonly blobRepository: IBlobRepository,
+        private readonly blobTemporaryRepository: IBlobRepository,
+        private readonly stageItemRepository: IStageItemRepository
+    ) {}
+
+    async execute({ message, body }: Params) {
+        // get stage
+        const items = await this.stageItemRepository.findAll()
+
+        // copy objects & blobs from .chrono/tmp to .chrono/objects & .chrono/blobs
+        for await (const item of items) {
+            const object = await this.objectTemporaryRepository.findOrFail(item.hash)
+            await this.objectRepository.copyFrom(this.objectTemporaryRepository, item.hash)
+
+            if (object.type === 'blob') {
+                await this.blobRepository.copyFrom(
+                    this.blobTemporaryRepository,
+                    object.head.blobHash
+                )
+            }
+        }
+
+        // create tree
+        const tree = ChronoObjectTree.fromEntries(items)
+
+        const { objectHash: treeHash } = await this.objectRepository.save(tree)
+        // create commit
+
+        const commit = ChronoObject.from(
+            {
+                type: 'commit',
+                tree: treeHash,
+                date: new Date().toISOString(),
+                message: message || '',
+            },
+            body
+        )
+
+        return this.objectRepository.save(commit)
+    }
+}