refactor(core)!: use facades in items use-cases

Author: zzhenryquezz

packages/core/app.spec.ts

@@ -23,7 +23,6 @@ import ShowItem from './use-cases/show-item/show-item'
 import CreateItem from './use-cases/create-item/create-item'
 import UpdateItem from './use-cases/update-item/update-item'
 import DeleteItem from './use-cases/delete-item/delete-item'
-import AppService, { AppServiceArgs } from './services/app-service'
 import ListScripts from './use-cases/list-scripts/list-scripts'
 import CreateScript from './use-cases/create-script/create-script'
 import UpdateScript from './use-cases/update-script/update-script'
@@ -34,12 +33,13 @@ import UpdateMenu from './use-cases/update-menu/update-menu'
 import UpdateDirectoryEntry from './use-cases/update-directory-entry/update-directory-entry'
 import ShowViews from './use-cases/show-views/show-views'
 import UpdateViews from './use-cases/update-views/update-views'
+import AppConfig from './config/app'
 
-function createUseCases(app: AppService) {
+function createUseCases(app: AppConfig) {
     return {
-        'list-workspaces': new ListWorkspaces(app.repositories.workspace),
-        'create-workspace': new CreateWorkspace(app.repositories.workspace, app.managers.drive),
-        'delete-workspace': new DeleteWorkspace(app.repositories.workspace),
+        'list-workspaces': new ListWorkspaces(app),
+        'create-workspace': new CreateWorkspace(app),
+        'delete-workspace': new DeleteWorkspace(app),
 
         'show-workspace-options': new ShowWorkspaceOptions(app),
         'update-workspace-options': new UpdateWorkspaceOptions(app),
@@ -78,12 +78,10 @@ function createUseCases(app: AppService) {
     }
 }
 
-export default class App extends AppService {
+export default class App {
     public cases: ReturnType<typeof createUseCases>
 
-    constructor(props: AppServiceArgs) {
-        super(props)
-
-        this.cases = createUseCases(this)
+    constructor(props: AppConfig) {
+        this.cases = createUseCases(props)
     }
 }

packages/core/app.ts

@@ -1,5 +1,7 @@
 import CollectionFacade from '../facades/collection'
 import DriveFacade from '../facades/drive'
+import ItemFacade from '../facades/item'
+import ItemFacade from '../facades/item'
 import Drive from '../gateways/drive/drive'
 import IWorkspaceRepository from '../repositories/workspace/workspace-repository'
 
@@ -10,6 +12,7 @@ interface Repositories {
 interface Facades {
     drive: DriveFacade
     collection: CollectionFacade
+    item: ItemFacade
 }
 
 export default class AppConfig {
@@ -23,10 +26,12 @@ export default class AppConfig {
 
         const driveFacade = new DriveFacade(drives)
         const collectionFacade = new CollectionFacade(driveFacade)
+        const itemFacade = new ItemFacade(collectionFacade)
 
         this.facades = {
             drive: driveFacade,
             collection: collectionFacade,
+            item: itemFacade,
         }
     }
 }

packages/core/config/app.ts

@@ -61,4 +61,28 @@ export default class DirectoryEntry {
             type: 'file',
         })
     }
+
+    public static encode(payload: any): Uint8Array {
+        const encoder = new TextEncoder()
+
+        if (Array.isArray(payload) || typeof payload === 'object') {
+            payload = JSON.stringify(payload, null, 4)
+        }
+
+        if (typeof payload === 'number') {
+            payload = String(payload)
+        }
+
+        if (typeof payload === 'string') {
+            payload = encoder.encode(payload)
+        }
+
+        return payload as Uint8Array
+    }
+
+    public static decode(payload: Uint8Array) {
+        const decoder = new TextDecoder()
+
+        return decoder.decode(payload)
+    }
 }

packages/core/entities/directory-entry.ts

@@ -0,0 +1,15 @@
+import Workspace from '../entities/workspace'
+import EntryItemRepository from '../repositories/item/implementations/entry-item-repository'
+import CollectionFacade from './collection'
+
+export default class ItemFacade {
+    constructor(public readonly collectionFacade: CollectionFacade) {}
+
+    public async createRepositoryFromWorkspace(workspace: Workspace, collectionId: string) {
+        const repository = this.collectionFacade.createRepository(workspace)
+
+        const collection = await repository.show(collectionId)
+
+        return new EntryItemRepository(collection, repository.drive)
+    }
+}

packages/core/facades/item.ts

@@ -10,28 +10,26 @@ import EntryItemRepository from './entry-item-repository'
 import ItemNotFound from '../../../exceptions/item-not-found'
 
 test.group('entry-item-repository (repository)', (group) => {
-    const memory = new InMemoryDrive()
-
-    const manager = new DriveManager({ memory }, 'memory')
-
-    const repository = new EntryItemRepository(manager)
+    const drive = new InMemoryDrive()
 
     const collection = CollectionFactory.create()
 
+    const repository = new EntryItemRepository(collection, drive)
+
     function saveMetas(metas: any[]) {
-        memory.createFile(DirectoryEntry.normalize(collection.path, '.is', 'metas.json'), metas)
+        drive.createFile(DirectoryEntry.normalize(collection.path, '.is', 'metas.json'), metas)
     }
 
     function getMetas() {
-        return memory.readArray(DirectoryEntry.normalize(collection.path, '.is', 'metas.json'))
+        return drive.readArray(DirectoryEntry.normalize(collection.path, '.is', 'metas.json'))
     }
 
-    group.each.teardown(() => memory.clear())
+    group.each.teardown(() => drive.clear())
 
     test('should list entries as items', async ({ expect }) => {
         const items = Array.from({ length: 20 })
             .map((_, i) => String(i))
-            .map((i) => memory.createDir(collection.path, i))
+            .map((i) => drive.createDir(collection.path, i))
             .map(({ name }) => {
                 const data = {
                     gender: faker.name.gender(),
@@ -43,15 +41,15 @@ test.group('entry-item-repository (repository)', (group) => {
 
         saveMetas(items)
 
-        const result = await repository.list(collection)
+        const result = await repository.list()
 
         expect(result).toEqual(items)
     })
 
     test('should show method return a item by id', async ({ expect }) => {
-        const entry = memory.createDir(collection.path, 'hello-word')
+        const entry = drive.createDir(collection.path, 'hello-word')
 
-        const result = await repository.show(collection, entry.name)
+        const result = await repository.show(entry.name)
 
         expect(result).toEqual(new Item({}, entry.name))
     })
@@ -60,46 +58,45 @@ test.group('entry-item-repository (repository)', (group) => {
         expect.assertions(1)
 
         await repository
-            .show(collection, 'invalid')
+            .show('invalid')
             .catch((err) => expect(err).toEqual(new ItemNotFound(collection.path, 'invalid')))
     })
 
     test('should create a item', async ({ expect }) => {
         const item = new Item({ age: faker.random.numeric() }, 'hello')
 
-        await repository.create(collection, item)
+        await repository.create(item)
 
-        const [result] = await repository.list(collection)
+        const [result] = await repository.list()
 
         expect(result.id).toEqual(item.id)
         expect(result.age).toEqual(item.age)
 
-        expect(manager.exists(collection.path, 'hello'))
+        const folderExists = await drive.exists(DirectoryEntry.normalize(collection.path, 'hello'))
+
+        expect(folderExists).toBe(true)
     })
 
     test('should update method throw an error if item not exists', async ({ expect }) => {
         expect.assertions(1)
 
         await repository
-            .update(collection, 'invalid', {
+            .update('invalid', {
                 hello: 'word',
             })
             .catch((err) => expect(err).toEqual(new ItemNotFound(collection.path, 'invalid')))
     })
 
     test('should update a item', async ({ expect }) => {
-        const item = await repository.create(
-            collection,
-            new Item({ age: faker.random.numeric() }, 'hello')
-        )
+        const item = await repository.create(new Item({ age: faker.random.numeric() }, 'hello'))
 
         saveMetas([item])
 
-        await repository.update(collection, item.id, {
+        await repository.update(item.id, {
             hello: 'word',
         })
 
-        const [result] = await repository.list(collection)
+        const [result] = await repository.list()
 
         expect(result.id).toBe(item.id)
         expect(result.age).toBe(item.age)
@@ -109,20 +106,19 @@ test.group('entry-item-repository (repository)', (group) => {
     })
 
     test('should update method move item folder when id is defined', async ({ expect }) => {
-        const item = await repository.create(
-            collection,
-            new Item({ age: faker.random.numeric() }, 'hello')
-        )
+        const item = await repository.create(new Item({ age: faker.random.numeric() }, 'hello'))
 
         saveMetas([item])
 
-        await repository.update(collection, item.id, {
+        await repository.update(item.id, {
             id: 'new-dir',
         })
 
-        const newItem = await repository.show(collection, 'new-dir')
+        const newItem = await repository.show('new-dir')
 
-        const folderExists = await manager.exists(collection.path, 'new-dir')
+        const folderExists = await drive.exists(
+            DirectoryEntry.normalize(collection.path, 'new-dir')
+        )
 
         expect(folderExists).toBe(true)
         expect(newItem.age).toBe(item.age)
@@ -132,21 +128,18 @@ test.group('entry-item-repository (repository)', (group) => {
         expect.assertions(1)
 
         await repository
-            .destroy(collection, 'invalid')
+            .destroy('invalid')
             .catch((err) => expect(err).toEqual(new ItemNotFound(collection.path, 'invalid')))
     })
 
     test('should delete an item', async ({ expect }) => {
-        const item = await repository.create(
-            collection,
-            new Item({ age: faker.random.numeric() }, 'hello')
-        )
+        const item = await repository.create(new Item({ age: faker.random.numeric() }, 'hello'))
 
         saveMetas([item])
 
-        await repository.destroy(collection, item.id)
+        await repository.destroy(item.id)
 
-        const items = await repository.list(collection)
+        const items = await repository.list()
         const metas = await getMetas()
 
         expect(items.length).toBe(0)