@vyr/service-gateway 0.0.34

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@vyr/service-gateway",
+  "version": "0.0.34",
+  "description": "",
+  "main": "./src/index.ts",
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.7.4"
+  },
+  "files": [
+    "package.json",
+    "src/"
+  ]
+}

package/src/GatewayService.ts

@@ -0,0 +1,78 @@
+import { Serialization, Listener, DeserializationObject } from '@vyr/engine'
+import { Service } from '@vyr/service'
+import { path, topic, Confirm, api } from '@vyr/gateway'
+import { bindExecutor, confirm, notify } from './executor'
+import { setAuthorization } from './request'
+
+interface RpcServiceConfig {
+    token: string
+}
+
+class GatewayService extends Service {
+    static notify = notify
+    static confirm = confirm
+    static client = ''
+
+    private _listener = new Listener<{ [k: string]: (data: DeserializationObject) => void }>()
+    private socket: any
+    private needTrigger = false
+    private queue: DeserializationObject[] = []
+
+    get url(): string {
+        return this.socket.uri
+    }
+
+    constructor(name: string, config: RpcServiceConfig) {
+        super(name)
+        const params = { path, extraHeaders: {}, autoConnect: false }
+        setAuthorization(params.extraHeaders, config.token)
+        //@ts-ignore
+        this.socket = new window.io(location.href, params)
+    }
+
+    async ready() {
+        bindExecutor(this)
+        this.socket.on(topic, (content: string) => {
+            const item = Serialization.parse(content) as DeserializationObject
+            this._delayTrigger(item)
+        })
+        this.socket.on('disconnect', () => {
+            const data = { client: GatewayService.client }
+            this.trigger(api.system.disconnect.path, data)
+        })
+    }
+
+    async start() {
+        await this.socket.connect()
+    }
+
+    trigger<T extends DeserializationObject = DeserializationObject>(api: string, data: T, other: DeserializationObject = {}) {
+        this._listener.trigger(api, data, other)
+    }
+    listen<T extends DeserializationObject = DeserializationObject>(api: string, cb: (data: T, ...others: any[]) => void) {
+        this._listener.listen(api, cb)
+    }
+    unlisten<T extends DeserializationObject = DeserializationObject>(api: string, cb: (data: T, ...others: any[]) => void) {
+        this._listener.unlisten(api, cb)
+    }
+
+    private _delayTrigger(item: DeserializationObject) {
+        this.queue.push(item)
+        if (this.needTrigger === true) return
+        this.needTrigger = true
+        setTimeout(() => this._executeQueue(), 160)
+    }
+    private _executeQueue() {
+        this.needTrigger = false
+        for (const { api, data, ...other } of this.queue) {
+            try {
+                this.trigger(api, data, other)
+            } catch (error) {
+                console.error(error)
+            }
+        }
+        this.queue.length = 0
+    }
+}
+
+export { GatewayService }

package/src/executor/index.ts

@@ -0,0 +1,37 @@
+import z from 'zod'
+import { api, Confirm } from '@vyr/gateway'
+import { request } from '../request'
+import { GatewayService } from '../GatewayService'
+
+const notify = (data: string) => { }
+
+const confirm = async (options: Partial<Confirm>, value?: string) => {
+    return options as Confirm
+}
+
+const connection = async (data: z.infer<typeof api.system.connection.noticeSchema>) => {
+    GatewayService.client = data.client
+}
+
+const onConfirm = async (data: z.infer<typeof api.system.confirm.noticeSchema>) => {
+    const result = await GatewayService.confirm(data.data)
+    data.data.value = result.value
+    data.data.success = result.success
+    await request({
+        url: api.system.confirm.path,
+        method: api.system.confirm.method,
+        data: data
+    })
+}
+
+const bindExecutor = (service: GatewayService) => {
+    service.listen(api.system.connection.path, connection)
+    service.listen(api.system.confirm.path, onConfirm)
+}
+
+export {
+    bindExecutor,
+    onConfirm,
+    notify,
+    confirm,
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from '@vyr/gateway'
+export * from './locale'
+export * from './request'
+export * from './GatewayService'

package/src/locale/Language.ts

@@ -0,0 +1,10 @@
+import { Locale } from "@vyr/locale";
+import { zhCnLanguageProvider, ZhCNLanguageProvider } from "./LanguageProvider";
+
+Locale.register(zhCnLanguageProvider)
+
+const language = Locale.getLanguage<ZhCNLanguageProvider>(zhCnLanguageProvider.name)
+
+export {
+    language
+}

package/src/locale/LanguageProvider.ts

@@ -0,0 +1,19 @@
+import { LanguageProvider } from '@vyr/locale'
+
+interface ZhCNLanguageProvider extends LanguageProvider {
+    'request.error.general': string
+    'request.error.401': string
+}
+
+const zhCnLanguageProvider: ZhCNLanguageProvider = {
+    id: 'zh_CN',
+    name: '@vyr/service-gateway',
+
+    'request.error.general': '服务错误，请稍后重试！',
+    'request.error.401': '无效的会话，或者会话已过期，请重新登录。'
+}
+
+export {
+    ZhCNLanguageProvider,
+    zhCnLanguageProvider,
+}

package/src/locale/index.ts

@@ -0,0 +1,2 @@
+export * from './LanguageProvider'
+export * from './Language'

package/src/request/index.ts

@@ -0,0 +1,57 @@
+import axios, { AxiosResponse, InternalAxiosRequestConfig } from 'axios'
+import { ObjectUtils } from '@vyr/engine';
+import { UserService } from '@vyr/service-user'
+import { language } from '../locale';
+import { GatewayService } from '../GatewayService';
+
+const request = axios.create({
+  baseURL: '',
+})
+
+const setClient = (headers: any) => {
+  headers['Client'] = GatewayService.client
+}
+
+const setAuthorization = (headers: any, token: string) => {
+  headers['Authorization'] = `Bearer ${token}`
+}
+
+request.interceptors.request.use(
+  (config: InternalAxiosRequestConfig) => {
+    const token = UserService.getToken()
+    if (token) setAuthorization(config.headers, token)
+    if (config.data instanceof FormData) delete config.headers['Content-Type']
+    setClient(config.headers)
+
+    return config
+  },
+  (error: any) => {
+    return Promise.reject(error);
+  }
+);
+
+request.interceptors.response.use(
+  (response: AxiosResponse) => {
+    return response
+  },
+  (error: any) => {
+    let message = language.get('request.error.general')
+    const { response, status } = error;
+    console.log(error)
+
+    if (status === 401) {
+      message = language.get('request.error.401')
+      setTimeout(UserService.logout, 1000);
+    } else if (ObjectUtils.isObject(response?.data)) {
+      if (response.data.message) message = response.data.message
+    }
+    GatewayService.notify(message)
+    return Promise.reject(error);
+  }
+)
+
+export {
+  request,
+  setClient,
+  setAuthorization,
+}