feat(desk): add entry-item-repository

Author: zzhenryquezz

packages/core/__tests__/app.ts

@@ -2,6 +2,7 @@ import CrudManager from '../gateways/crud-manager'
 import DriveManager from '../gateways/drive/manager'
 import NodeVMEvaluation from '../gateways/evaluation/implementations/node-vm-evaluation'
 import CollectionRepository from '../repositories/collection/implementations/collection-repository'
+import EntryItemRepository from '../repositories/item/implementations/entry-item-repository'
 import AppService, { AppServiceArgs } from '../services/app-service'
 import InMemoryCrud from './gateways/in-memory-crud'
 import InMemoryDrive from './gateways/in-memory-drive'
@@ -28,6 +29,7 @@ export default class InMemoryApp extends AppService {
         const repositories: AppServiceArgs['repositories'] = {
             workspace: workspaceRepository,
             collection: new CollectionRepository(managers.drive),
+            item: new EntryItemRepository(managers.drive),
         }
 
         super({

packages/core/__tests__/gateways/in-memory-drive.ts

@@ -37,6 +37,8 @@ export default class InMemoryDrive implements Drive {
 
         if (!entry) return
 
+        entry.name = DirectoryEntry.basename(target)
+
         entry.path = target
     }
 
@@ -55,13 +57,17 @@ export default class InMemoryDrive implements Drive {
     public async write(path: string, content: Uint8Array) {
         this.content.set(DirectoryEntry.normalize(path), content)
 
-        this.entries.push(DirectoryEntry.file(path))
+        if (!this.entries.some((e) => e.path === path)) {
+            this.entries.push(DirectoryEntry.file(path))
+        }
     }
 
-    public async mkdir(entryPath: string) {
-        const entry = DirectoryEntry.directory(entryPath)
+    public async mkdir(path: string) {
+        const entry = DirectoryEntry.directory(path)
 
-        this.entries.push(entry)
+        if (!this.entries.some((e) => e.path === path)) {
+            this.entries.push(entry)
+        }
 
         return entry
     }
@@ -76,8 +82,8 @@ export default class InMemoryDrive implements Drive {
         this.entries.splice(index, 1)
     }
 
-    public createFile(entryPath: string, content: any = '') {
-        const entry = DirectoryEntry.file(entryPath)
+    public createFile(path: string, content: any = '') {
+        const entry = DirectoryEntry.file(path)
 
         if (Array.isArray(content)) {
             content = JSON.stringify(content)
@@ -87,7 +93,10 @@ export default class InMemoryDrive implements Drive {
             content = JSON.stringify(content)
         }
 
-        this.entries.push(entry)
+        if (!this.entries.some((e) => e.path === path)) {
+            this.entries.push(entry)
+        }
+
         this.content.set(entry.path, Buffer.from(content))
     }
 

packages/core/entities/collection.ts

@@ -3,6 +3,7 @@ import Column from './column'
 export default class Collection {
     public id: string
     public workspaceId?: string
+
     public name: string
     public path: string
 

packages/core/entities/directory-entry.ts

@@ -8,15 +8,11 @@ export default class DirectoryEntry {
     }
 
     public static normalize(...paths: string[]) {
-        let result = paths
+        const result = paths
             .map((p) => p.split('/'))
             .reduce((all, p) => all.concat(p), [])
             .join('/')
 
-        if (result[0] === '/') {
-            result = result.slice(1)
-        }
-
         return result
     }
 

packages/core/exceptions/item-not-found.spec.ts

@@ -3,14 +3,13 @@ import ItemNotFound from './item-not-found'
 
 test.group('item not found exception (unit)', () => {
     test('should have correct format', ({ expect }) => {
-        const workspaceId = 'hello'
         const collectionId = 'word'
         const itemId = 'my-item'
 
-        const error = new ItemNotFound(workspaceId, collectionId, itemId)
+        const error = new ItemNotFound(collectionId, itemId)
 
         expect(error.message).toBe('Item not found')
         expect(error.i18nKey).toBe('errors.itemNotFound')
-        expect(error.i18nArgs).toEqual([workspaceId, collectionId, itemId])
+        expect(error.i18nArgs).toEqual([collectionId, itemId])
     })
 })

packages/core/exceptions/item-not-found.ts

@@ -1,11 +1,11 @@
 import BaseException from './base'
 
 export default class ItemNotFound extends BaseException {
-    constructor(workspaceId: string, collectionId: string, itemId: string) {
+    constructor(collectionId: string, itemId: string) {
         super('Item not found')
 
         this.i18nKey = 'errors.itemNotFound'
 
-        this.i18nArgs = [workspaceId, collectionId, itemId]
+        this.i18nArgs = [collectionId, itemId]
     }
 }

packages/core/gateways/drive/manager.ts

@@ -1,3 +1,4 @@
+import DirectoryEntry from '../../entities/directory-entry'
 import Drive from './drive'
 
 export default class DriveManager<T extends Record<string, Drive> = any> implements Drive {
@@ -47,49 +48,61 @@ export default class DriveManager<T extends Record<string, Drive> = any> impleme
         return result
     }
 
-    public async exists(entryPath: string) {
-        return this.execute((d) => d.exists(entryPath))
+    public async exists(...paths: string[]) {
+        const normalize = DirectoryEntry.normalize(...paths)
+
+        return this.execute((d) => d.exists(normalize))
     }
 
-    public async list(entryPath: string) {
-        return this.execute((d) => d.list(entryPath))
+    public async list(...paths: string[]) {
+        const normalize = DirectoryEntry.normalize(...paths)
+
+        return this.execute((d) => d.list(normalize))
     }
 
-    public async get(entryPath: string) {
-        return this.execute((d) => d.get(entryPath))
+    public async get(...paths: string[]) {
+        const normalize = DirectoryEntry.normalize(...paths)
+
+        return this.execute((d) => d.get(normalize))
     }
 
-    public async mkdir(entryPath: string) {
-        return this.execute((d) => d.mkdir(entryPath))
+    public async mkdir(...paths: string[]) {
+        const normalize = DirectoryEntry.normalize(...paths)
+
+        return this.execute((d) => d.mkdir(normalize))
     }
 
     public async move(source: string, target: string) {
         return this.execute((d) => d.move(source, target))
     }
 
-    public async read(entryPath: string) {
-        return this.execute((d) => d.read(entryPath))
+    public async read(...paths: string[]) {
+        const normalize = DirectoryEntry.normalize(...paths)
+
+        return this.execute((d) => d.read(normalize))
     }
 
-    public async readAsString(entryPath: string) {
+    public async readAsString(...paths: string[]) {
         const decoder = new TextDecoder()
 
-        const uint = await this.execute((d) => d.read(entryPath))
+        const uint = await this.read(...paths)
 
         return uint ? decoder.decode(uint) : uint
     }
 
-    public async write(entryPath: string, content: Uint8Array | string) {
+    public async write(path: string, content: Uint8Array | string) {
         const encoder = new TextEncoder()
 
         if (typeof content === 'string') {
             content = encoder.encode(content)
         }
 
-        return this.execute((d) => d.write(entryPath, content as Uint8Array))
+        return this.execute((d) => d.write(path, content as Uint8Array))
     }
 
-    public async delete(entryPath: string) {
-        return this.execute((d) => d.delete(entryPath))
+    public async delete(...paths: string[]) {
+        const normalize = DirectoryEntry.normalize(...paths)
+
+        return this.execute((d) => d.delete(normalize))
     }
 }

packages/core/gateways/evaluation/implementations/node-vm-evaluation.spec.ts.ts

@@ -1,7 +1,7 @@
 import { test } from '@japa/runner'
 import NodeVMEvaluation from './node-vm-evaluation'
 
-test.group('script-service (service)', () => {
+test.group('node-vm-evaluation (unit)', () => {
     const service = new NodeVMEvaluation()
 
     test('should execute script and return result', async ({ expect }) => {

packages/core/gateways/evaluation/implementations/node-vm-evaluation.ts

@@ -2,7 +2,6 @@ import vm from 'vm'
 import util from 'util'
 
 import * as ts from 'typescript'
-import IEvaluationService from '../evaluation'
 
 function tsCompile(source: string, options: ts.TranspileOptions = {}): string {
     // Default options -- you could also perform a merge, or use the project tsconfig.json
@@ -20,7 +19,7 @@ const format = (args: any) => {
     return util.inspect(args)
 }
 
-export default class NodeVMEvaluation implements IEvaluationService {
+export default class ScriptService {
     protected async _evaluate(code: string, scope?: Record<string, any>) {
         const logs: string[] = []
         let result = null

packages/core/repositories/item/implementations/entry-item-repository.spec.ts

@@ -0,0 +1,155 @@
+import { test } from '@japa/runner'
+import { faker } from '@faker-js/faker'
+
+import DirectoryEntry from '../../../entities/directory-entry'
+import Item from '../../../entities/item'
+import DriveManager from '../../../gateways/drive/manager'
+import CollectionFactory from '../../../__tests__/factories/collections'
+import InMemoryDrive from '../../../__tests__/gateways/in-memory-drive'
+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 collection = CollectionFactory.create()
+
+    function saveMetas(metas: any[]) {
+        memory.createFile(DirectoryEntry.normalize(collection.path, '.is', 'metas.json'), metas)
+    }
+
+    function getMetas() {
+        return memory.readArray(DirectoryEntry.normalize(collection.path, '.is', 'metas.json'))
+    }
+
+    group.each.teardown(() => memory.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(({ name }) => {
+                const data = {
+                    gender: faker.name.gender(),
+                    age: faker.datatype.number({ min: 1, max: 99 }),
+                }
+
+                return new Item(data, name)
+            })
+
+        saveMetas(items)
+
+        const result = await repository.list(collection)
+
+        expect(result).toEqual(items)
+    })
+
+    test('should show method return a item by id', async ({ expect }) => {
+        const entry = memory.createDir(collection.path, 'hello-word')
+
+        const result = await repository.show(collection, entry.name)
+
+        expect(result).toEqual(new Item({}, entry.name))
+    })
+
+    test('should show method throw an error if item not exists', async ({ expect }) => {
+        expect.assertions(1)
+
+        await repository
+            .show(collection, '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)
+
+        const [result] = await repository.list(collection)
+
+        expect(result.id).toEqual(item.id)
+        expect(result.age).toEqual(item.age)
+
+        expect(manager.exists(collection.path, 'hello'))
+    })
+
+    test('should update method throw an error if item not exists', async ({ expect }) => {
+        expect.assertions(1)
+
+        await repository
+            .update(collection, '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')
+        )
+
+        saveMetas([item])
+
+        await repository.update(collection, item.id, {
+            hello: 'word',
+        })
+
+        const [result] = await repository.list(collection)
+
+        expect(result.id).toBe(item.id)
+        expect(result.age).toBe(item.age)
+        expect(result.hello).toBe('word')
+        expect(result._createdAt).toBe(item._createdAt)
+        expect(result._updatedAt).not.toBe(item._updatedAt)
+    })
+
+    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')
+        )
+
+        saveMetas([item])
+
+        await repository.update(collection, item.id, {
+            id: 'new-dir',
+        })
+
+        const newItem = await repository.show(collection, 'new-dir')
+
+        const folderExists = await manager.exists(collection.path, 'new-dir')
+
+        expect(folderExists).toBe(true)
+        expect(newItem.age).toBe(item.age)
+    })
+
+    test('should destroy method throw an error if item not exists', async ({ expect }) => {
+        expect.assertions(1)
+
+        await repository
+            .destroy(collection, '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')
+        )
+
+        saveMetas([item])
+
+        await repository.destroy(collection, item.id)
+
+        const items = await repository.list(collection)
+        const metas = await getMetas()
+
+        expect(items.length).toBe(0)
+        expect(metas.length).toBe(0)
+    })
+})