@kevisual/query 0.0.39 → 0.0.41

package/dist/query-api.js

@@ -0,0 +1,432 @@
+// src/adapter.ts
+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 = globalThis?.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?.params, ...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 {
+    if (opts.body && typeof opts.body === "object" && !(opts.body instanceof FormData)) {
+      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);
+  });
+};
+
+// src/query.ts
+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;
+    console.log("query post", url, body, options);
+    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",
+        req
+      });
+    }
+    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",
+          req
+        });
+      }
+    });
+  }
+  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;
+  }
+}
+
+// src/create-query/index.ts
+var createQueryByRoutes = (list) => {
+  const obj = {};
+  for (const route of list) {
+    if (!obj[route.path]) {
+      obj[route.path] = {};
+    }
+    obj[route.path][route.key] = route;
+  }
+  const code = `
+import { createQueryApi } from '@kevisual/query/api';
+const api = ${generateApiCode(obj)} as const;
+const queryApi = createQueryApi({ api });
+export { queryApi };
+`;
+  return code;
+};
+function generateApiCode(obj) {
+  let code = `{
+`;
+  const paths = Object.keys(obj);
+  for (let i = 0;i < paths.length; i++) {
+    const path = paths[i];
+    const methods = obj[path];
+    code += `  "${path}": {
+`;
+    const keys = Object.keys(methods);
+    for (let j = 0;j < keys.length; j++) {
+      const key = keys[j];
+      const route = methods[key];
+      if (route?.id) {
+        if (route.id.startsWith("rand-")) {
+          delete route.id;
+        }
+      }
+      const description = route?.metadata?.summary || route?.description || "";
+      const args = route?.metadata?.args || {};
+      if (description || Object.keys(args).length > 0) {
+        code += `    /**
+`;
+        if (description) {
+          const escapedDescription = description.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/\n/g, `
+     * `);
+          code += `     * ${escapedDescription}
+`;
+        }
+        if (Object.keys(args).length > 0) {
+          if (description) {
+            code += `     *
+`;
+          }
+          code += `     * @param data - Request parameters
+`;
+          for (const [argName, schema] of Object.entries(args)) {
+            const argSchema = schema;
+            const argType = argSchema.type || "unknown";
+            const argDesc = argSchema.description || "";
+            let typeInfo = argType;
+            if (argType === "string" && argSchema.enum) {
+              typeInfo = argSchema.enum.map((v) => `"${v}"`).join(" | ");
+            } else if (argType === "number" || argType === "integer") {
+              const constraints = [];
+              if (argSchema.minimum !== undefined)
+                constraints.push(`min: ${argSchema.minimum}`);
+              if (argSchema.maximum !== undefined)
+                constraints.push(`max: ${argSchema.maximum}`);
+              if (argSchema.exclusiveMinimum !== undefined)
+                constraints.push(`> ${argSchema.exclusiveMinimum}`);
+              if (argSchema.exclusiveMaximum !== undefined)
+                constraints.push(`< ${argSchema.exclusiveMaximum}`);
+              if (constraints.length > 0)
+                typeInfo += ` (${constraints.join(", ")})`;
+            } else if (argType === "string") {
+              const constraints = [];
+              if (argSchema.minLength !== undefined)
+                constraints.push(`minLength: ${argSchema.minLength}`);
+              if (argSchema.maxLength !== undefined)
+                constraints.push(`maxLength: ${argSchema.maxLength}`);
+              if (argSchema.format)
+                constraints.push(`format: ${argSchema.format}`);
+              if (constraints.length > 0)
+                typeInfo += ` (${constraints.join(", ")})`;
+            }
+            const escapedArgDesc = argDesc.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/\n/g, " ");
+            code += `     * @param data.${argName} - {${typeInfo}}${escapedArgDesc ? " " + escapedArgDesc : ""}
+`;
+          }
+        }
+        code += `     */
+`;
+      }
+      code += `    "${key}": ${JSON.stringify(route, null, 2).split(`
+`).map((line, idx) => idx === 0 ? line : "    " + line).join(`
+`)}`;
+      if (j < keys.length - 1) {
+        code += ",";
+      }
+      code += `
+`;
+    }
+    code += `  }`;
+    if (i < paths.length - 1) {
+      code += ",";
+    }
+    code += `
+`;
+  }
+  code += "}";
+  return code;
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/pick.mjs
+function pick(obj, keys) {
+  const result = {};
+  for (let i = 0;i < keys.length; i++) {
+    const key = keys[i];
+    if (Object.hasOwn(obj, key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+// src/query-api.ts
+class QueryApi {
+  query;
+  constructor(opts) {
+    this.query = opts?.query ?? new Query;
+    if (opts?.api) {
+      this.createApi(opts.api);
+    }
+  }
+  post(pos, data, opts) {
+    const _pos = pick(pos, ["path", "key", "id"]);
+    return this.query.post({
+      ..._pos,
+      payload: data
+    }, opts);
+  }
+  createApi(api) {
+    const that = this;
+    const apiEntries = Object.entries(api);
+    const keepPaths = ["createApi", "query", "post"];
+    for (const [path, methods] of apiEntries) {
+      if (keepPaths.includes(path))
+        continue;
+      if (!that[path]) {
+        that[path] = {};
+      }
+      for (const [key, pos] of Object.entries(methods)) {
+        that[path][key] = (data, opts) => {
+          const _pos = pick(pos, ["path", "key", "id"]);
+          return that.query.post({
+            ..._pos,
+            payload: data
+          }, opts);
+        };
+      }
+    }
+  }
+}
+function createQueryApi(opts) {
+  return new QueryApi(opts);
+}
+export {
+  createQueryByRoutes,
+  createQueryApi,
+  QueryApi
+};

package/dist/query-browser.d.ts

@@ -180,6 +180,9 @@ declare class Query {
      */
     stop?: boolean;
     qws: QueryWs;
+    /**
+     * 默认是 /client/router或者 默认是 /api/router
+     */
     isClient: boolean;
     constructor(opts?: QueryOptions);
     setQueryWs(qws: QueryWs): void;
@@ -236,13 +239,6 @@ declare class BaseQuery<T extends Query = Query, R extends {
     post<R = any, P = any>(data: P, options?: DataOpts): Promise<Result<R>>;
     get<R = any, P = any>(data: P, options?: DataOpts): Promise<Result<R>>;
 }
-/**
- * @deprecated
- * 前端调用后端QueryRouter, 默认路径 /client/router
- */
-declare class ClientQuery extends Query {
-    constructor(opts?: QueryOpts$1);
-}
 
 type QueryOpts = {
     url?: string;
@@ -269,5 +265,5 @@ declare class QueryClient extends Query {
     removeToken(): void;
 }
 
-export { BaseQuery, ClientQuery, Query, QueryClient, QueryWs, adapter, wrapperError };
+export { BaseQuery, Query, QueryClient, QueryWs, adapter, wrapperError };
 export type { Data, DataOpts, QueryOptions, QueryOpts, QueryWsOpts, Result };