@kevisual/api 0.0.44 → 0.0.47

package/dist/query-ai.js

@@ -255,7 +255,7 @@ class Query {
   }
 }
 
-// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-define.js
+// node_modules/.pnpm/@kevisual+router@0.0.70/node_modules/@kevisual/router/dist/router-define.js
 class Chain {
   object;
   app;

package/dist/query-app.d.ts

@@ -12,7 +12,28 @@ declare class QueryApp extends BaseQuery {
     });
     getList(data: any, opts?: DataOpts): any;
     getPublicApp(data: any, opts?: DataOpts): any;
-    getApp(data: any, opts?: DataOpts): any;
+    getApp(data: {
+        key?: string;
+        version?: string;
+        /**
+         * 当app不存在，会创建一个新的，
+         * 之后上传文件就好了，会执行检测任务
+         */
+        create?: boolean;
+    }, opts?: DataOpts): any;
+    /**
+     * 发布应用
+     * @param data
+     * @param opts
+     * @returns
+     */
+    publichApp(data: {
+        id?: string;
+        username?: string;
+        detect?: boolean;
+        appKey?: string;
+        version?: string;
+    }, opts?: DataOpts): any;
 }
 
 export { QueryApp, appDefine, userAppDefine };

package/dist/query-app.js

@@ -255,7 +255,7 @@ class Query {
   }
 }
 
-// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-define.js
+// node_modules/.pnpm/@kevisual+router@0.0.70/node_modules/@kevisual/router/dist/router-define.js
 class Chain {
   object;
   app;
@@ -515,6 +515,13 @@ class QueryApp extends BaseQuery {
       data
     }, opts);
   }
+  publichApp(data, opts) {
+    return this.query.post({
+      path: "app",
+      key: "publish",
+      data: { detect: true, ...data }
+    }, opts);
+  }
 }
 export {
   userAppDefine,

package/dist/query-proxy.js

@@ -679,7 +679,7 @@ class QueryClient extends Query {
   }
 }
 
-// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-browser.js
+// node_modules/.pnpm/@kevisual+router@0.0.70/node_modules/@kevisual/router/dist/router-browser.js
 var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 var nanoid$2 = (size = 21) => {
   let id = "";
@@ -938,6 +938,44 @@ function requireEventemitter3() {
 }
 var eventemitter3Exports = requireEventemitter3();
 var EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+function isPlainObject$1(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  const hasObjectPrototype = proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null;
+  if (!hasObjectPrototype) {
+    return false;
+  }
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+function merge$1(target, source) {
+  const sourceKeys = Object.keys(source);
+  for (let i = 0;i < sourceKeys.length; i++) {
+    const key = sourceKeys[i];
+    if (isUnsafeProperty(key)) {
+      continue;
+    }
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) {
+      target[key] = merge$1(targetValue, sourceValue);
+    } else if (Array.isArray(sourceValue)) {
+      target[key] = merge$1([], sourceValue);
+    } else if (isPlainObject$1(sourceValue)) {
+      target[key] = merge$1({}, sourceValue);
+    } else if (targetValue === undefined || sourceValue !== undefined) {
+      target[key] = sourceValue;
+    }
+  }
+  return target;
+}
+function isMergeableValue(value) {
+  return isPlainObject$1(value) || Array.isArray(value);
+}
 
 class MockProcess {
   emitter;
@@ -976,7 +1014,7 @@ class MockProcess {
     this.process = undefined;
   }
 }
-var listenProcess = async ({ app, mockProcess, params, timeout = 10 * 60 * 60 * 1000 }) => {
+var listenProcess = async ({ app, mockProcess, params = {}, timeout = 10 * 60 * 60 * 1000 }) => {
   const process = mockProcess || new MockProcess;
   let isEnd = false;
   const timer = setTimeout(() => {
@@ -989,23 +1027,25 @@ var listenProcess = async ({ app, mockProcess, params, timeout = 10 * 60 * 60 *
   }, timeout);
   const getParams = async () => {
     return new Promise((resolve) => {
-      process.on((msg) => {
+      process.on((params2) => {
         if (isEnd)
           return;
         isEnd = true;
         clearTimeout(timer);
-        resolve(msg);
+        resolve(params2 || {});
       });
     });
   };
   try {
-    const { payload = {}, ...rest } = await getParams();
-    const msg = { ...params, ...rest, payload: { ...params?.payload, ...payload } };
+    const _params = await getParams();
+    const mergeParams = merge$1(params, _params);
+    const msg = mergeParams?.message || {};
+    const ctx = mergeParams?.context || {};
     if (!msg.path && !msg.id) {
       const route = app.routes.find((r) => r.path !== "router");
       msg.id = route?.id;
     }
-    const result = await app.run(msg);
+    const result = await app.run(msg, ctx);
     const response = {
       success: true,
       data: result,
@@ -1015,6 +1055,7 @@ var listenProcess = async ({ app, mockProcess, params, timeout = 10 * 60 * 60 *
       process.exit?.(0);
     });
   } catch (error) {
+    console.error("Error in listenProcess:", error);
     process.send?.({
       success: false,
       error: error.message
@@ -8011,14 +8052,17 @@ var toJSONSchema = (route) => {
   return pickValues;
 };
 var fromJSONSchema = (route) => {
-  const args = route?.metadata?.args || {};
+  const args = route?.metadata?.args;
+  if (!args)
+    return route;
   const keys = Object.keys(args);
   const newArgs = {};
   for (let key of keys) {
     const item = args[key];
     newArgs[key] = fromJSONSchema$1(item);
   }
-  return newArgs;
+  route.metadata.args = newArgs;
+  return route;
 };
 
 class QueryRouter {
@@ -8357,8 +8401,8 @@ class QueryRouter {
     }
     return listenProcess({ app: this, params, ...opts });
   }
-  static toJSONSchema = toJSONSchema;
-  static fromJSONSchema = fromJSONSchema;
+  toJSONSchema = toJSONSchema;
+  fromJSONSchema = fromJSONSchema;
 }
 
 class QueryRouterServer extends QueryRouter {

package/dist/query-remote.d.ts

@@ -0,0 +1 @@
+export { RemoteApp } from '@kevisual/remote-app';

package/dist/query-remote.js

@@ -0,0 +1,433 @@
+// node_modules/.pnpm/@kevisual+remote-app@0.0.4/node_modules/@kevisual/remote-app/dist/app.js
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var require_eventemitter3 = __commonJS((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+var import__ = __toESM(require_eventemitter3(), 1);
+
+class RemoteApp {
+  mainApp;
+  url;
+  id;
+  emitter;
+  isConnected;
+  ws;
+  remoteIsConnected;
+  isError = false;
+  autoReconnect;
+  maxReconnectAttempts;
+  reconnectDelay;
+  maxReconnectDelay;
+  enableBackoff;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  isManuallyClosed = false;
+  constructor(opts) {
+    this.mainApp = opts?.app;
+    const token = opts.token;
+    const url = opts.url;
+    const id = opts.id;
+    this.emitter = opts?.emitter || new import__.default;
+    const _url = new URL(url);
+    if (token) {
+      _url.searchParams.set("token", token);
+    }
+    _url.searchParams.set("id", id);
+    this.url = _url.toString();
+    this.id = id;
+    this.autoReconnect = opts?.autoReconnect ?? true;
+    this.maxReconnectAttempts = opts?.maxReconnectAttempts ?? Infinity;
+    this.reconnectDelay = opts?.reconnectDelay ?? 1000;
+    this.maxReconnectDelay = opts?.maxReconnectDelay ?? 30000;
+    this.enableBackoff = opts?.enableBackoff ?? true;
+    this.init();
+  }
+  async isConnect() {
+    const that = this;
+    if (this.isConnected) {
+      return true;
+    }
+    if (this.reconnectTimer !== null) {
+      console.log(`远程应用 ${this.id} 正在重连中...`);
+    }
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve(false);
+        that.emitter.off("open", listenOnce);
+      }, 5000);
+      const listenOnce = () => {
+        clearTimeout(timeout);
+        that.isConnected = true;
+        that.remoteIsConnected = true;
+        resolve(true);
+      };
+      that.emitter.once("open", listenOnce);
+    });
+  }
+  getWsURL(url) {
+    const { protocol } = new URL(url);
+    const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+    const wsURL = url.toString().replace(protocol, wsProtocol);
+    return wsURL;
+  }
+  async init() {
+    if (!this.url) {
+      throw new Error("No url provided for remote app");
+    }
+    if (!this.id) {
+      throw new Error("No id provided for remote app");
+    }
+    this.isError = false;
+    if (this.ws) {
+      this.ws.close();
+    }
+    const ws = new WebSocket(this.getWsURL(this.url));
+    const that = this;
+    ws.onopen = function() {
+      that.isConnected = true;
+      that.onOpen();
+    };
+    ws.onclose = function() {
+      that.isConnected = false;
+      that.onClose();
+    };
+    ws.onmessage = function(event) {
+      that.onMessage(event.data);
+    };
+    ws.onerror = function(error) {
+      that.onError(error);
+    };
+    this.ws = ws;
+  }
+  onOpen() {
+    this.isError = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.emitter.emit("open", this.id);
+  }
+  onClose() {
+    console.log("远程应用关闭:", this.id);
+    this.isConnected = false;
+    this.emitter.emit("close", this.id);
+    if (this.autoReconnect && !this.isManuallyClosed) {
+      this.scheduleReconnect();
+    }
+  }
+  calculateReconnectDelay() {
+    if (!this.enableBackoff) {
+      return this.reconnectDelay;
+    }
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+    return Math.min(delay, this.maxReconnectDelay);
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error(`远程应用 ${this.id} 已达到最大重连次数 ${this.maxReconnectAttempts}，停止重连`);
+      this.emitter.emit("maxReconnectAttemptsReached", this.id);
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    const delay = this.calculateReconnectDelay();
+    this.reconnectAttempts++;
+    console.log(`远程应用 ${this.id} 将在 ${delay}ms 后尝试第 ${this.reconnectAttempts} 次重连`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      try {
+        this.init();
+      } catch (error) {
+        console.error(`远程应用 ${this.id} 重连失败:`, error);
+        this.emitter.emit("reconnectFailed", { id: this.id, attempt: this.reconnectAttempts, error });
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  disconnect() {
+    this.isManuallyClosed = true;
+    this.autoReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+  reconnect() {
+    this.isManuallyClosed = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.init();
+  }
+  onMessage(data) {
+    this.emitter.emit("message", data);
+  }
+  onError(error) {
+    console.error("远程应用错误:", this.id, error);
+    this.isError = true;
+    this.emitter.emit("error", error);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return () => {
+      this.emitter.off(event, listener);
+    };
+  }
+  json(data) {
+    this.ws.send(JSON.stringify(data));
+  }
+  listenProxy() {
+    const remoteApp = this;
+    const app = this.mainApp;
+    const listenFn = async (event) => {
+      try {
+        const data = event.toString();
+        const body = JSON.parse(data);
+        const bodyData = body?.data;
+        const message = bodyData?.message || {};
+        const context = bodyData?.context || {};
+        if (body?.code === 401) {
+          console.error("远程应用认证失败，请检查 token 是否正确");
+          this.isError = true;
+          return;
+        }
+        if (body?.type !== "proxy")
+          return;
+        if (!body.id) {
+          remoteApp.json({
+            id: body.id,
+            data: {
+              code: 400,
+              message: "id is required"
+            }
+          });
+          return;
+        }
+        const res = await app.run(message, context);
+        remoteApp.json({
+          id: body.id,
+          data: {
+            code: res.code,
+            data: res.data,
+            message: res.message
+          }
+        });
+      } catch (error) {
+        console.error("处理远程代理请求出错:", error);
+      }
+    };
+    remoteApp.json({
+      id: this.id,
+      type: "registryClient"
+    });
+    remoteApp.emitter.on("message", listenFn);
+    const closeMessage = () => {
+      remoteApp.emitter.off("message", listenFn);
+    };
+    remoteApp.emitter.once("close", () => {
+      closeMessage();
+    });
+    return () => {
+      closeMessage();
+    };
+  }
+}
+export {
+  RemoteApp
+};

package/dist/query-shop.js

@@ -255,7 +255,7 @@ class Query {
   }
 }
 
-// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-define.js
+// node_modules/.pnpm/@kevisual+router@0.0.70/node_modules/@kevisual/router/dist/router-define.js
 class Chain {
   object;
   app;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.44",
+  "version": "0.0.47",
   "description": "",
   "main": "mod.ts",
   "scripts": {
@@ -21,18 +21,20 @@
   "type": "module",
   "devDependencies": {
     "@kevisual/cache": "^0.0.5",
-    "@kevisual/code-builder": "^0.0.5",
+    "@kevisual/code-builder": "^0.0.6",
     "@kevisual/query": "^0.0.39",
-    "@kevisual/router": "^0.0.69",
+    "@kevisual/remote-app": "^0.0.4",
+    "@kevisual/router": "^0.0.70",
     "@kevisual/types": "^0.0.12",
     "@kevisual/use-config": "^1.0.30",
-    "@types/spark-md5": "^3.0.5",
     "@types/bun": "^1.3.8",
     "@types/crypto-js": "^4.2.2",
     "@types/node": "^25.2.0",
+    "@types/spark-md5": "^3.0.5",
     "crypto-js": "^4.2.0",
     "dotenv": "^17.2.3",
-    "fast-glob": "^3.3.3"
+    "fast-glob": "^3.3.3",
+    "ws": "npm:@kevisual/ws"
   },
   "dependencies": {
     "@kevisual/js-filter": "^0.0.5",

package/query/query-app/query-app.ts

@@ -22,11 +22,38 @@ export class QueryApp extends BaseQuery {
       data: data,
     }, opts);
   }
-  getApp(data: any, opts?: DataOpts) {
+  getApp(data: {
+    key?: string;
+    version?: string;
+    /** 
+     * 当app不存在，会创建一个新的，
+     * 之后上传文件就好了，会执行检测任务
+     */
+    create?: boolean;
+  }, opts?: DataOpts) {
     return this.query.post({
       path: 'app',
       key: 'get',
       data: data,
     }, opts);
   }
+  /**
+   * 发布应用
+   * @param data 
+   * @param opts 
+   * @returns 
+   */
+  publichApp(data: {
+    id?: string;
+    username?: string,
+    detect?: boolean,
+    appKey?: string;
+    version?: string;
+  }, opts?: DataOpts) {
+    return this.query.post({
+      path: 'app',
+      key: 'publish',
+      data: { detect: true, ...data },
+    }, opts);
+  }
 }

package/query/query-remote/index.ts

@@ -0,0 +1,5 @@
+import { RemoteApp } from '@kevisual/remote-app'
+
+export {
+  RemoteApp
+}