@vyr/service-asset 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyr/service-asset",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "",
   "main": "./src/index.ts",
   "author": "",

package/src/AssetService.ts

@@ -1,9 +1,10 @@
+import z from 'zod'
 import { Service } from '@vyr/service'
 import { DraggableData, DraggableEndType, } from '@vyr/declare'
 import { runtime } from '@vyr/runtime'
-import { Descriptor, DeserializationObject } from '@vyr/engine'
-import { RpcService, Message, VirtualNode, request } from '@vyr/service-rpc'
-import { AssetMethodProvider } from "./AssetMethodProvider"
+import { AsyncTask, Descriptor, DeserializationObject } from '@vyr/engine'
+import { GatewayService, api, VirtualNode, request } from '@vyr/service-gateway'
+import { bindExecutor } from './executor'
 
 class AssetService extends Service {
     static key = 'asset'
@@ -23,7 +24,7 @@ class AssetService extends Service {
         window.URL.revokeObjectURL(url)
     }
 
-    private _provider = new AssetMethodProvider(this)
+    readonly initializeTask = new AsyncTask()
     readonly root
 
     constructor(name: string, root: VirtualNode) {
@@ -33,82 +34,191 @@ class AssetService extends Service {
     }
 
     async ready() {
-        this._provider.listen()
+        const gatewayService = runtime.get<GatewayService>('gateway')
+        bindExecutor(gatewayService)
     }
 
     async start() {
-        await this._provider.ready.done()
+        await this.initializeTask.done()
     }
 
-    select(path: string) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.select.RequestMessage(path))
+    async open(url: string) {
+        const data: z.infer<typeof api.asset.open.requestSchema> = {
+            url
+        }
+        await request({
+            url: api.asset.open.path,
+            method: api.asset.open.method,
+            data
+        })
     }
 
-    open(path: string) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.open.RequestMessage(path))
-    }
-
-    close(path: string) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.close.RequestMessage(path))
+    async close(url: string) {
+        const data: z.infer<typeof api.asset.close.requestSchema> = {
+            url
+        }
+        await request({
+            url: api.asset.close.path,
+            method: api.asset.close.method,
+            data
+        })
     }
 
     /**新增文件 */
-    create(fileType: boolean, name: string, suffix: string, parent: string, content: string) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.create.RequestMessage(fileType, name, suffix, parent, content))
+    async create(fileType: boolean, name: string, suffix: string, parent: string, content: string) {
+        const data: z.infer<typeof api.asset.create.requestSchema> = {
+            fileType,
+            name,
+            suffix,
+            parent,
+            content
+        }
+        await request({
+            url: api.asset.create.path,
+            method: api.asset.create.method,
+            data
+        })
     }
 
     /**删除文件 */
-    delete(path: string[] | string) {
-        const requestData = Array.isArray(path) ? path : [path]
-        if (requestData.length === 0) return
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.delete.RequestMessage(requestData))
+    async delete(path: string[] | string) {
+        const urls = Array.isArray(path) ? path : [path]
+        if (urls.length === 0) return
+
+        const data: z.infer<typeof api.asset.delete.requestSchema> = {
+            urls
+        }
+        await request({
+            url: api.asset.delete.path,
+            method: api.asset.delete.method,
+            data
+        })
+    }
+
+    async add(url: string, node: DeserializationObject<Descriptor>[], parent: string) {
+
+        const data: z.infer<typeof api.asset.add.requestSchema> = {
+            url,
+            parent,
+            node,
+            next: ''
+        }
+        await request({
+            url: api.asset.add.path,
+            method: api.asset.add.method,
+            data
+        })
+    }
+
+    async remove(url: string, uuids: string[]) {
+
+        const data: z.infer<typeof api.asset.remove.requestSchema> = {
+            url,
+            uuids
+        }
+        await request({
+            url: api.asset.remove.path,
+            method: api.asset.remove.method,
+            data
+        })
+    }
+
+    async dragdrap(url: string, type: DraggableEndType, dragData: DraggableData<{ uuids: string[] }>, targetData: DraggableData<{ uuid: string }>) {
+
+        const data: z.infer<typeof api.asset.dragdrap.requestSchema> = {
+            url,
+            type,
+            dragData,
+            targetData,
+            next: ""
+        }
+        await request({
+            url: api.asset.dragdrap.path,
+            method: api.asset.dragdrap.method,
+            data
+        })
+    }
+
+    async rename(url: string, newName: string) {
+
+        const data: z.infer<typeof api.asset.rename.requestSchema> = {
+            url,
+            newName
+        }
+        await request({
+            url: api.asset.rename.path,
+            method: api.asset.rename.method,
+            data
+        })
     }
 
-    add(path: string, node: DeserializationObject<Descriptor>[], parent: string) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.add.RequestMessage(path, parent, node))
-    }
+    /**剪切文件,将文件移动到指定目录 */
+    async cut(urls: string[], target: string) {
+        if (urls.length === 0) return
 
-    remove(path: string, uuids: string[]) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.remove.RequestMessage(path, uuids))
+        const data: z.infer<typeof api.asset.cut.requestSchema> = {
+            urls,
+            target
+        }
+        await request({
+            url: api.asset.cut.path,
+            method: api.asset.cut.method,
+            data
+        })
     }
 
-    dragdrap(path: string, type: DraggableEndType, dragData: DraggableData<{ uuids: string[] }>, targetData: DraggableData<{ uuid: string }>) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.dragdrap.RequestMessage(path, type, dragData, targetData))
+    /**复制文件 */
+    async copy(urls: string[], target: string) {
+        if (urls.length === 0) return
+
+        const data: z.infer<typeof api.asset.copy.requestSchema> = {
+            urls,
+            target
+        }
+        await request({
+            url: api.asset.copy.path,
+            method: api.asset.copy.method,
+            data
+        })
+    }
+    async update(url: string, node: DeserializationObject<Descriptor>) {
+
+        const data: z.infer<typeof api.asset.update.requestSchema> = {
+            url,
+            node
+        }
+        await request({
+            url: api.asset.update.path,
+            method: api.asset.update.method,
+            data
+        })
     }
 
-    rename(path: string, newName: string) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.rename.RequestMessage(newName, path))
+    async read(url: string) {
+        const res = await request.get<string>(url, { responseType: 'text' })
+        return res.data
     }
 
-    /**剪切文件,将文件移动到指定目录 */
-    cut(path: string[], target: string) {
-        if (path.length === 0) return
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.cut.RequestMessage(path, target))
-    }
+    async download(id: string, filename: string) {
 
-    /**复制文件 */
-    copy(path: string[], target: string) {
-        if (path.length === 0) return
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.copy.RequestMessage(path, target))
-    }
-    update(path: string, content: DeserializationObject<Descriptor>) {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.update.RequestMessage(path, content))
+        const params: z.infer<typeof api.asset.download.requestSchema> = {
+            id
+        }
+        const res = await request({
+            url: api.asset.download.path,
+            method: api.asset.download.method,
+            params,
+            responseType: 'blob'
+        })
+        AssetService.save(filename, res.data)
     }
 
-    async read(url: string) {
-        const res = await request.get<string>(url, { responseType: 'text' })
+    async upload(formData: FormData) {
+        const res = await request({
+            url: api.asset.upload.path,
+            method: api.asset.upload.method,
+            data: formData,
+        })
         return res.data
     }
 }

package/src/executor/index.ts

@@ -0,0 +1,140 @@
+import z from 'zod'
+import { ArrayUtils, Descriptor, DeserializationObject } from "@vyr/engine"
+import { DataService, runtime } from "@vyr/runtime"
+import { api, request, GatewayService, VirtualNode } from "@vyr/service-gateway"
+import { AssetService } from "../AssetService"
+
+const _clear = (items: Descriptor[], item: VirtualNode) => {
+    if (items.length === 0) return
+    for (const stickupItem of items) {
+        if (stickupItem.uuid !== item.uuid) continue
+        ArrayUtils.remove(items, stickupItem)
+        return
+    }
+}
+
+const connection = async (data: z.infer<typeof api.system.connection.noticeSchema>) => {
+    const { data: result } = await request.post<z.infer<typeof api.asset.initialize.responseSchema>>(api.asset.initialize.path, {})
+
+    const service = runtime.get<AssetService>('asset')
+    service.root.clear()
+    for (const sub of result.root.children) service.root.add(new VirtualNode(sub))
+
+    const gatewayService = runtime.get<GatewayService>('gateway')
+    gatewayService.trigger(api.asset.initialize.path, result)
+    service.initializeTask.run()
+}
+
+const disconnect = (data: z.infer<typeof api.system.disconnect.noticeSchema>) => {
+    const service = runtime.get<AssetService>('asset')
+    service.root.clearUser(data.client)
+}
+
+const open = (data: z.infer<typeof api.asset.open.noticeSchema>) => {
+    const asset = VirtualNode.get<VirtualNode>(data.url)
+    if (asset) asset.addUser(data.client)
+}
+
+const close = (data: z.infer<typeof api.asset.close.noticeSchema>) => {
+    const asset = VirtualNode.get<VirtualNode>(data.url)
+    if (asset) asset.removeUser(data.client)
+}
+
+const create = (data: z.infer<typeof api.asset.create.noticeSchema>) => {
+    const asset = VirtualNode.get<VirtualNode>(data.parent)
+    if (asset === null) return
+    asset.add(new VirtualNode(VirtualNode.deserialization(data.asset)))
+    asset.sort()
+}
+
+const _delete = (data: z.infer<typeof api.asset.delete.noticeSchema>) => {
+    const dataService = runtime.get<DataService>('data')
+    for (const path of data.urls) {
+        const node = VirtualNode.get<VirtualNode>(path)
+        if (node === null) return
+        const ancestor = node.traceAncestor<VirtualNode>(false)
+        if (ancestor.parent === null) continue
+
+        _clear(dataService.footer.status.stickupItems, node)
+        ancestor.parent.remove(node)
+    }
+}
+
+const add = (data: z.infer<typeof api.asset.add.noticeSchema>) => {
+    const parent = Descriptor.get<Descriptor>(data.parent)
+    if (parent === null) return
+
+    if (data.next) {
+        for (const item of data.node) {
+            const node = Descriptor.create(item)
+            parent.insertBefore(node.uuid, data.next)
+        }
+    } else {
+        for (const item of data.node) {
+            const node = Descriptor.create(item)
+            parent.add(node)
+        }
+    }
+}
+
+const remove = (data: z.infer<typeof api.asset.remove.noticeSchema>) => {
+    const dataService = runtime.get<DataService>('data')
+
+    for (const uuid of data.uuids) {
+        const target = Descriptor.get<Descriptor>(uuid)
+        if (target === null) continue
+        const ancestor = target.traceAncestor(false)
+        if (ancestor.parent === null) continue
+        ancestor.parent.remove(target)
+
+        ArrayUtils.removeByKey(dataService.sidebar.selectAll, 'uuid', target.uuid)
+        ArrayUtils.removeByKey(dataService.sidebar.status.stickupItems, 'uuid', target.uuid)
+    }
+}
+
+const update = (data: z.infer<typeof api.asset.update.noticeSchema>) => {
+    const node = data.node as DeserializationObject<Descriptor>
+    const descriptor = Descriptor.get<Descriptor>(data.node.uuid)
+    if (descriptor) descriptor.syncWith(node)
+}
+
+const dragdrap = (data: z.infer<typeof api.asset.dragdrap.noticeSchema>) => {
+    const service = runtime.get<AssetService>('asset')
+    const dataService = runtime.get<DataService>('data')
+    if (data.url !== dataService.sidebar.url) return
+
+    const method = data.next ? 'insertBefore' : data.type
+    const target = data.next || data.targetData.data.uuid
+
+    for (const uuid of data.dragData.data.uuids) {
+        //@ts-ignore
+        service.root[method](uuid, target)
+    }
+}
+
+const bindExecutor = (gatewayService: GatewayService) => {
+    gatewayService.listen(api.system.connection.path, connection)
+    gatewayService.listen(api.system.disconnect.path, disconnect)
+    gatewayService.listen(api.asset.create.path, create)
+    gatewayService.listen(api.asset.delete.path, _delete)
+    gatewayService.listen(api.asset.add.path, add)
+    gatewayService.listen(api.asset.remove.path, remove)
+    gatewayService.listen(api.asset.open.path, open)
+    gatewayService.listen(api.asset.close.path, close)
+    gatewayService.listen(api.asset.update.path, update)
+    gatewayService.listen(api.asset.dragdrap.path, dragdrap)
+}
+
+export {
+    bindExecutor,
+    connection,
+    disconnect,
+    open,
+    close,
+    create,
+    _delete as delete,
+    add,
+    remove,
+    update,
+    dragdrap,
+}

package/src/AssetMethodProvider.ts

@@ -1,135 +0,0 @@
-import { ArrayUtils, AsyncTask, Descriptor } from "@vyr/engine"
-import { DataService, runtime, SidebarNavigator } from "@vyr/runtime"
-import { Message, RpcService, VirtualNode } from '@vyr/service-rpc'
-import { AssetService } from "./AssetService"
-
-class AssetMethodProvider {
-    readonly ready = new AsyncTask()
-    readonly service
-
-    constructor(service: AssetService) {
-        this.service = service
-    }
-
-    private _clear(items: Descriptor[], item: VirtualNode) {
-        if (items.length === 0) return
-        for (const stickupItem of items) {
-            if (stickupItem.uuid !== item.uuid) continue
-            ArrayUtils.remove(items, stickupItem)
-            return
-        }
-    }
-
-    listen() {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.listen(Message.rpc.connection.Method, this._connection)
-        rpcService.listen(Message.rpc.disconnect.Method, this._disconnect)
-        rpcService.listen(Message.asset.initialize.Method, this._initialize)
-        rpcService.listen(Message.asset.create.Method, this._create)
-        rpcService.listen(Message.asset.delete.Method, this._delete)
-        rpcService.listen(Message.asset.add.Method, this._add)
-        rpcService.listen(Message.asset.remove.Method, this._remove)
-        rpcService.listen(Message.asset.open.Method, this._open)
-        rpcService.listen(Message.asset.close.Method, this._close)
-        rpcService.listen(Message.asset.update.Method, this._update)
-        rpcService.listen(Message.asset.dragdrap.Method, this._dragdrap)
-    }
-
-    _connection = async (msg: InstanceType<typeof Message['rpc']['connection']['NoticeMessage']>) => {
-        const rpcService = runtime.get<RpcService>('rpc')
-        rpcService.send(new Message.asset.initialize.RequestMessage())
-    }
-
-    _disconnect = (msg: InstanceType<typeof Message['rpc']['disconnect']['NoticeMessage']>) => {
-        this.service.root.clearUser(msg.params.client)
-    }
-
-    _initialize = (msg: InstanceType<typeof Message['asset']['initialize']['NoticeMessage']>) => {
-        this.service.root.clear()
-        for (const sub of msg.params.root.children) this.service.root.add(new VirtualNode(sub))
-        this.ready.run()
-    }
-
-    _open = (msg: InstanceType<typeof Message['asset']['open']['NoticeMessage']>) => {
-        const asset = VirtualNode.get<VirtualNode>(msg.params.url)
-        if (asset) asset.addUser(msg.params.client)
-    }
-
-    _close = (msg: InstanceType<typeof Message['asset']['close']['NoticeMessage']>) => {
-        const asset = VirtualNode.get<VirtualNode>(msg.params.url)
-        if (asset) asset.removeUser(msg.params.client)
-    }
-
-    _create = (msg: InstanceType<typeof Message['asset']['create']['NoticeMessage']>) => {
-        const asset = VirtualNode.get<VirtualNode>(msg.params.parent)
-        if (asset === null) return
-        asset.add(new VirtualNode(VirtualNode.deserialization(msg.params.node)))
-        asset.sort()
-    }
-
-    _delete = (msg: InstanceType<typeof Message['asset']['delete']['NoticeMessage']>) => {
-        const dataService = runtime.get<DataService>('data')
-        for (const path of msg.params.urls) {
-            const node = VirtualNode.get<VirtualNode>(path)
-            if (node === null) return
-            const ancestor = node.traceAncestor<VirtualNode>(false)
-            if (ancestor.parent === null) continue
-
-            this._clear(dataService.footer.status.stickupItems, node)
-            ancestor.parent.remove(node)
-        }
-    }
-
-    _add = (msg: InstanceType<typeof Message['asset']['add']['NoticeMessage']>) => {
-        const parent = Descriptor.get<Descriptor>(msg.params.parent)
-        if (parent === null) return
-
-        if (msg.params.next) {
-            for (const item of msg.params.node) {
-                const node = Descriptor.create(item)
-                parent.insertBefore(node.uuid, msg.params.next)
-            }
-        } else {
-            for (const item of msg.params.node) {
-                const node = Descriptor.create(item)
-                parent.add(node)
-            }
-        }
-    }
-
-    _remove = (msg: InstanceType<typeof Message['asset']['remove']['NoticeMessage']>) => {
-        const dataService = runtime.get<DataService>('data')
-        const navigator = dataService.sidebar.get<SidebarNavigator>(AssetService.key)
-
-        for (const uuid of msg.params.uuids) {
-            const target = Descriptor.get<Descriptor>(uuid)
-            if (target === null) continue
-            const ancestor = target.traceAncestor(false)
-            if (ancestor.parent === null) continue
-            ancestor.parent.remove(target)
-
-            ArrayUtils.removeByKey(navigator.selectAll, 'uuid', target.uuid)
-            ArrayUtils.removeByKey(navigator.status.stickupItems, 'uuid', target.uuid)
-        }
-    }
-
-    _update = (msg: InstanceType<typeof Message['asset']['update']['NoticeMessage']>) => {
-        const descriptor = Descriptor.get<Descriptor>(msg.params.content.uuid)
-        if (descriptor) descriptor.syncWith(msg.params.content)
-    }
-
-    _dragdrap = (msg: InstanceType<typeof Message['asset']['dragdrap']['NoticeMessage']>) => {
-        const dataService = runtime.get<DataService>('data')
-        const navigator = dataService.sidebar.get<SidebarNavigator>(AssetService.key)
-        if (msg.params.url !== navigator.url) return
-
-        const method = msg.params.next ? 'insertBefore' : msg.params.type
-        const target = msg.params.next || msg.params.targetData.data.uuid
-
-        for (const uuid of msg.params.dragData.data.uuids) {
-            this.service.root[method](uuid, target)
-        }
-    }
-}
-
-export { AssetMethodProvider }