@kevisual/api 0.0.41 → 0.0.43

package/dist/query-app.js

@@ -0,0 +1,523 @@
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query-browser.js
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
+};
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = window?.location?.origin || "http://localhost:51515";
+    url = new URL(opts.url, origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
+        }
+      }
+    }
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    headers = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    body = JSON.stringify(opts.body);
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
+    }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    success: false,
+    message: message || "api request error",
+    showError: (fn) => {},
+    noMsg: true
+  };
+  return result;
+};
+
+class Query {
+  adapter;
+  url;
+  beforeRequest;
+  afterResponse;
+  headers;
+  timeout;
+  stop;
+  qws;
+  isClient = false;
+  constructor(opts) {
+    this.adapter = opts?.adapter || adapter;
+    const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
+    this.url = opts?.url || defaultURL;
+    this.headers = opts?.headers || {
+      "Content-Type": "application/json"
+    };
+    this.timeout = opts?.timeout || 60000 * 3;
+    if (opts.beforeRequest) {
+      this.beforeRequest = opts.beforeRequest;
+    } else {
+      this.beforeRequest = async (opts2) => {
+        const token = globalThis?.localStorage?.getItem("token");
+        if (token) {
+          opts2.headers = {
+            ...opts2.headers,
+            Authorization: `Bearer ${token}`
+          };
+        }
+        return opts2;
+      };
+    }
+  }
+  setQueryWs(qws) {
+    this.qws = qws;
+  }
+  setStop(stop) {
+    this.stop = stop;
+  }
+  async get(params, options) {
+    return this.post(params, options);
+  }
+  async post(body, options) {
+    const url = options?.url || this.url;
+    const { headers, adapter: adapter2, beforeRequest, afterResponse, timeout, ...rest } = options || {};
+    const _headers = { ...this.headers, ...headers };
+    const _adapter = adapter2 || this.adapter;
+    const _beforeRequest = beforeRequest || this.beforeRequest;
+    const _afterResponse = afterResponse || this.afterResponse;
+    const _timeout = timeout || this.timeout;
+    const req = {
+      url,
+      headers: _headers,
+      body,
+      timeout: _timeout,
+      ...rest
+    };
+    try {
+      if (_beforeRequest) {
+        const res = await _beforeRequest(req);
+        if (res === false) {
+          return wrapperError({
+            code: 500,
+            message: "request is cancel",
+            req
+          });
+        }
+      }
+    } catch (e) {
+      console.error("request beforeFn error", e, req);
+      return wrapperError({
+        code: 500,
+        message: "api request beforeFn error"
+      });
+    }
+    if (this.stop && !options?.noStop) {
+      const that = this;
+      await new Promise((resolve) => {
+        let timer = 0;
+        const detect = setInterval(() => {
+          if (!that.stop) {
+            clearInterval(detect);
+            resolve(true);
+          }
+          timer++;
+          if (timer > 30) {
+            console.error("request stop: timeout", req.url, timer);
+          }
+        }, 1000);
+      });
+    }
+    return _adapter(req).then(async (res) => {
+      try {
+        if (_afterResponse) {
+          return await _afterResponse(res, {
+            req,
+            res,
+            fetch: adapter2
+          });
+        }
+        return res;
+      } catch (e) {
+        console.error("request afterFn error", e, req);
+        return wrapperError({
+          code: 500,
+          message: "api request afterFn error"
+        });
+      }
+    });
+  }
+  before(fn) {
+    this.beforeRequest = fn;
+  }
+  after(fn) {
+    this.afterResponse = fn;
+  }
+  async fetchText(urlOrOptions, options) {
+    let _options = { ...options };
+    if (typeof urlOrOptions === "string" && !_options.url) {
+      _options.url = urlOrOptions;
+    }
+    if (typeof urlOrOptions === "object") {
+      _options = { ...urlOrOptions, ..._options };
+    }
+    const res = await adapter({
+      method: "GET",
+      ..._options,
+      headers: {
+        ...this.headers,
+        ..._options?.headers || {}
+      }
+    });
+    if (res && !res.code) {
+      return {
+        code: 200,
+        data: res
+      };
+    }
+    return res;
+  }
+}
+
+// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-define.js
+class Chain {
+  object;
+  app;
+  constructor(object, opts) {
+    this.object = object;
+    this.app = opts?.app;
+  }
+  get key() {
+    return this.object.key;
+  }
+  get path() {
+    return this.object.path;
+  }
+  setDescription(desc) {
+    this.object.description = desc;
+    return this;
+  }
+  setMeta(metadata) {
+    this.object.metadata = metadata;
+    return this;
+  }
+  setPath(path) {
+    this.object.path = path;
+    return this;
+  }
+  setMiddleware(middleware) {
+    this.object.middleware = middleware;
+    return this;
+  }
+  setKey(key) {
+    this.object.key = key;
+    return this;
+  }
+  setId(key) {
+    this.object.id = key;
+    return this;
+  }
+  setRun(run) {
+    this.object.run = run;
+    return this;
+  }
+  define(run) {
+    this.object.run = run;
+    return this;
+  }
+  createRoute() {
+    this.app.route(this.object).addTo(this.app);
+    return this;
+  }
+}
+
+class QueryChain {
+  obj = {};
+  query;
+  omitKeys = ["metadata", "description", "validator"];
+  constructor(value, opts) {
+    this.obj = value || {};
+    this.query = opts?.query;
+    if (opts?.omitKeys)
+      this.omitKeys = opts.omitKeys;
+  }
+  omit(obj, key = []) {
+    const newObj = { ...obj };
+    key.forEach((k) => {
+      delete newObj[k];
+    });
+    return newObj;
+  }
+  getKey(queryData) {
+    const obj = this.omit(this.obj, this.omitKeys);
+    return {
+      ...obj,
+      ...queryData
+    };
+  }
+  post(data, options) {
+    const _queryData = this.getKey(data);
+    return this.query.post(_queryData, options);
+  }
+  get(data, options) {
+    const _queryData = this.getKey(data);
+    return this.query.get(_queryData, options);
+  }
+}
+class QueryUtil {
+  obj;
+  app;
+  query;
+  constructor(object, opts) {
+    this.obj = object;
+    this.app = opts?.app;
+    this.query = opts?.query;
+  }
+  static createFormObj(object, opts) {
+    return new QueryUtil(object, opts);
+  }
+  static create(value, opts) {
+    const obj = value;
+    return new QueryUtil(obj, opts);
+  }
+  get(key) {
+    return this.obj[key];
+  }
+  chain(key, opts) {
+    const obj = this.obj[key];
+    let newOpts = { app: this.app, ...opts };
+    return new QueryUtil.Chain(obj, newOpts);
+  }
+  queryChain(key, opts) {
+    const value = this.obj[key];
+    let newOpts = { query: this.query, ...opts };
+    return new QueryUtil.QueryChain(value, newOpts);
+  }
+  static Chain = Chain;
+  static QueryChain = QueryChain;
+  get routeObject() {
+    return this.obj;
+  }
+}
+
+// query/index.ts
+var query = new Query;
+var clientQuery = new Query({ url: "/client/router" });
+
+// query/query-app/defines/user-app-list.ts
+var appDefine = QueryUtil.create({
+  getApp: {
+    path: "app",
+    key: "get",
+    description: "获取应用信息"
+  },
+  updateApp: {
+    path: "app",
+    key: "update",
+    description: "更新应用信息"
+  },
+  deleteApp: {
+    path: "app",
+    key: "delete",
+    description: "删除应用信息"
+  },
+  listApps: {
+    path: "app",
+    key: "list",
+    description: "列出所有应用信息"
+  },
+  canUploadFiles: {
+    path: "app",
+    key: "canUploadFiles",
+    description: "检查是否可以上传文件"
+  },
+  uploadFiles: {
+    path: "app",
+    key: "uploadFiles",
+    description: "上传文件"
+  },
+  publishApp: {
+    path: "app",
+    key: "publish",
+    description: "发布应用"
+  },
+  getMinioList: {
+    path: "app",
+    key: "get-minio-list",
+    description: "获取 MinIO 文件列表"
+  },
+  detectVersionList: {
+    path: "app",
+    key: "detectVersionList",
+    description: "检测版本列表并同步 MinIO 数据"
+  },
+  publicList: {
+    path: "app",
+    key: "public-list",
+    description: "获取公开应用列表"
+  }
+});
+
+// query/query-app/defines/user-app.ts
+var userAppDefine = QueryUtil.create({
+  listUserApps: {
+    path: "user-app",
+    key: "list",
+    description: "列出当前用户的所有应用（不包含 data 字段）"
+  },
+  getUserApp: {
+    path: "user-app",
+    key: "get",
+    description: "获取用户应用信息，可以指定 id 或 key"
+  },
+  updateUserApp: {
+    path: "user-app",
+    key: "update",
+    description: "更新或创建用户应用"
+  },
+  deleteUserApp: {
+    path: "user-app",
+    key: "delete",
+    description: "删除用户应用及关联数据"
+  },
+  testUserApp: {
+    path: "user-app",
+    key: "test",
+    description: "对 user-app 的数据进行测试，获取版本信息"
+  }
+});
+
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query.js
+class BaseQuery {
+  query;
+  queryDefine;
+  constructor(opts) {
+    if (opts?.clientQuery) {
+      this.query = opts.clientQuery;
+    } else {
+      this.query = opts?.query;
+    }
+    if (opts.queryDefine) {
+      this.queryDefine = opts.queryDefine;
+      this.queryDefine.query = this.query;
+    }
+  }
+  get chain() {
+    return this.queryDefine.queryChain;
+  }
+  post(data, options) {
+    return this.query.post(data, options);
+  }
+  get(data, options) {
+    return this.query.get(data, options);
+  }
+}
+
+// query/query-app/query-app.ts
+class QueryApp extends BaseQuery {
+  appDefine = appDefine;
+  userAppDefine = userAppDefine;
+  constructor(opts) {
+    super(opts);
+    this.appDefine.query = this.query;
+    this.userAppDefine.query = this.query;
+  }
+  getList(data, opts) {
+    return this.appDefine.queryChain("listApps").post(data, opts);
+  }
+  getPublicApp(data, opts) {
+    return this.query.post({
+      path: "app",
+      key: "getApp",
+      data
+    }, opts);
+  }
+  getApp(data, opts) {
+    return this.query.post({
+      path: "app",
+      key: "get",
+      data
+    }, opts);
+  }
+}
+export {
+  userAppDefine,
+  appDefine,
+  QueryApp
+};

package/dist/query-config.d.ts

@@ -0,0 +1,71 @@
+import { Query } from '@kevisual/query';
+
+/**
+ * 配置查询
+ * @updatedAt 2025-12-03 10:33:00
+ */
+
+type QueryConfigOpts = {
+    query?: Query;
+};
+type Config<T = any> = {
+    id?: string;
+    title?: string;
+    key?: string;
+    description?: string;
+    data?: T;
+    createdAt?: string;
+    updatedAt?: string;
+};
+type UploadConfig = {
+    key?: string;
+    version?: string;
+};
+type PostOpts = {
+    token?: string;
+    payload?: Record<string, any>;
+};
+declare const defaultConfigKeys: readonly ["upload.json", "workspace.json", "ai.json", "user.json", "life.json"];
+type DefaultConfigKey = (typeof defaultConfigKeys)[number];
+declare class QueryConfig {
+    query: Query;
+    constructor(opts?: QueryConfigOpts);
+    post<T = Config>(data: any): Promise<any>;
+    getConfig({ id, key }: {
+        id?: string;
+        key?: string;
+    }, opts?: PostOpts): Promise<any>;
+    updateConfig(data: Config, opts?: PostOpts): Promise<any>;
+    deleteConfig(data: {
+        id?: string;
+        key?: string;
+    }, opts?: PostOpts): Promise<any>;
+    listConfig(opts?: PostOpts): Promise<any>;
+    /**
+     * 获取上传配置
+     * @returns
+     */
+    getUploadConfig(opts?: PostOpts): Promise<any>;
+    /**
+     * 更新上传配置
+     * @param data
+     * @returns
+     */
+    updateUploadConfig(data: Config, opts?: PostOpts): Promise<any>;
+    /**
+     * 检测配置是否存在
+     * @param id
+     * @returns
+     */
+    detectConfig(opts?: PostOpts): Promise<any>;
+    /**
+     * 获取配置, 获取默认的配置项
+     * @param key
+     * @returns
+     */
+    getConfigByKey(key: DefaultConfigKey, opts?: PostOpts): Promise<any>;
+    getByKey<T = any>(key: string, opts?: PostOpts): Promise<any>;
+}
+
+export { QueryConfig, defaultConfigKeys };
+export type { Config, UploadConfig };