@snail-js/api 0.1.21 → 0.1.23

package/dist/snail-api.js

@@ -3717,16 +3717,6 @@ class IndexDBCache {
     });
   }
 }
-var RequestMethodEnum = /* @__PURE__ */ ((RequestMethodEnum2) => {
-  RequestMethodEnum2["GET"] = "Get";
-  RequestMethodEnum2["HEAD"] = "Head";
-  RequestMethodEnum2["POST"] = "Post";
-  RequestMethodEnum2["PUT"] = "Put";
-  RequestMethodEnum2["DELETE"] = "delete";
-  RequestMethodEnum2["PATCH"] = "Patch";
-  RequestMethodEnum2["OPTIONS"] = "Options";
-  return RequestMethodEnum2;
-})(RequestMethodEnum || {});
 class SnailServerStatusCodeRuleOptions {
   constructor() {
     __publicField(this, "key");
@@ -3764,13 +3754,6 @@ class SseOptions {
     __publicField(this, "version");
   }
 }
-var EventType = /* @__PURE__ */ ((EventType2) => {
-  EventType2["Success"] = "success";
-  EventType2["Error"] = "error";
-  EventType2["hitCache"] = "hitCache";
-  EventType2["Finish"] = "finish";
-  return EventType2;
-})(EventType || {});
 function createCache(optios) {
   const { type } = optios;
   if (type === CacheType.Custom) {
@@ -3891,14 +3874,8 @@ function isSpecialResponse(response) {
   return !contentType.includes("application/json");
 }
 const METHOD_KEY = Symbol("SNAIL_METHOD_KEY");
-const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
-const Api = (url = "", config) => {
-  return (target) => {
-    Reflect.defineMetadata(API_CONFIG_KEY, { url, ...config }, target);
-  };
-};
 const createMethodDecorator = (method) => {
-  return (path = "", name) => {
+  return (path = "", options) => {
     return (target, propertyKey) => {
       const methodOptions = Reflect.getMetadata(
         METHOD_KEY,
@@ -3907,25 +3884,29 @@ const createMethodDecorator = (method) => {
       );
       if (methodOptions) {
         console.error("only one method decorator for a request function!");
-        console.error(`you must chose only one method decorator[@${method} or @${methodOptions.method}]`);
-        throw new TypeError(`Multiple decorators are used for the same request function`);
+        console.error(
+          `you must chose only one method decorator[@${method} or @${methodOptions.method}]`
+        );
+        throw new TypeError(
+          `Multiple decorators are used for the same request function`
+        );
       }
       Reflect.defineMetadata(
         METHOD_KEY,
-        { method, path, name },
+        { method, path, ...options },
         target,
         propertyKey
       );
     };
   };
 };
-const Get = createMethodDecorator(RequestMethodEnum.GET);
-const Post = createMethodDecorator(RequestMethodEnum.POST);
-const Put = createMethodDecorator(RequestMethodEnum.PUT);
-const Delete = createMethodDecorator(RequestMethodEnum.DELETE);
-const Patch = createMethodDecorator(RequestMethodEnum.PATCH);
-const Options = createMethodDecorator(RequestMethodEnum.OPTIONS);
-const Head = createMethodDecorator(RequestMethodEnum.HEAD);
+const Get = createMethodDecorator("GET");
+const Post = createMethodDecorator("POST");
+const Put = createMethodDecorator("PUT");
+const Delete = createMethodDecorator("DELETE");
+const Patch = createMethodDecorator("PATCH");
+const Options = createMethodDecorator("OPTIONS");
+const Head = createMethodDecorator("HEAD");
 const SERVER_CONFIG_KEY = Symbol("SANIL_SERVER_CONFIG_KEY");
 const Server = (config) => {
   return (target) => {
@@ -3976,6 +3957,54 @@ const HitSource = (...sources) => {
     Reflect.defineMetadata(CACHE_EXPIRE_SOURCE_KEY, sources, target);
   };
 };
+class SnailEvent {
+  constructor() {
+    __publicField(this, "eventMap");
+    __publicField(this, "onceWrapperMap");
+    __publicField(this, "on", (eventName, listener) => {
+      if (typeof listener !== "function") {
+        throw new TypeError("Handler must be a function");
+      }
+      const listeners = this.eventMap.get(eventName) || /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      this.eventMap.set(eventName, listeners);
+    });
+    __publicField(this, "off", (eventName, listener) => {
+      const listeners = this.eventMap.get(eventName);
+      if (!listeners) return;
+      if (this.onceWrapperMap.has(listener)) {
+        this.onceWrapperMap.delete(listener);
+      }
+      if (listeners.size === 0) {
+        this.eventMap.delete(eventName);
+      }
+    });
+    __publicField(this, "once", (eventName, listener) => {
+      const onceHandler = (data) => {
+        try {
+          listener.apply(this, [data]);
+        } finally {
+          this.off(eventName, onceHandler);
+          this.onceWrapperMap.delete(listener);
+        }
+      };
+      this.onceWrapperMap.set(listener, onceHandler);
+      this.on(eventName, onceHandler);
+    });
+    __publicField(this, "emit", (eventName, ...args) => {
+      const listeners = this.eventMap.get(eventName);
+      if (!listeners || listeners.size === 0) return false;
+      listeners.forEach((listener) => {
+        Promise.resolve().then(() => {
+          listener.apply(this, args);
+        });
+      });
+      return true;
+    });
+    this.eventMap = /* @__PURE__ */ new Map();
+    this.onceWrapperMap = /* @__PURE__ */ new Map();
+  }
+}
 const versionHandlers = {
   [VersioningType.Uri]: (version, versioning) => {
     const prefix = versioning.prefix || "v";
@@ -4019,7 +4048,8 @@ function applyVersioning(version, versioning) {
 const UPLOAD_PROGRESS_KEY = Symbol("SNAIL_UPLOAD_PROGRESS_KEY");
 const DOWNLOAD_PROGRESS_KEY = Symbol("SNAIL_DOWNLOAD_PROGRESS_KEY");
 class SnailMethod {
-  constructor(apiInstance, target, propertyKey, args) {
+  // private Args: any[] = [];
+  constructor(apiInstance, target, propertyKey) {
     // 私有属性
     // private serverInstance: SnailServer;
     __publicField(this, "Name");
@@ -4029,144 +4059,111 @@ class SnailMethod {
     __publicField(this, "Request");
     __publicField(this, "Response");
     __publicField(this, "Error");
-    __publicField(this, "eventMap");
-    __publicField(this, "onceWrapperMap");
+    __publicField(this, "EventEmit");
+    // private eventMap: Map<string, Set<EventHandler>>;
+    // private onceWrapperMap: Map<EventHandler, EventHandler>;
     __publicField(this, "propertyKey");
     __publicField(this, "Url", "");
     __publicField(this, "Path", "");
-    __publicField(this, "Method", RequestMethodEnum.GET);
+    __publicField(this, "Method", "GET");
+    __publicField(this, "Adapter");
     __publicField(this, "Version");
-    __publicField(this, "Args", []);
-    __publicField(this, "send", async () => {
+    __publicField(this, "send", (...args) => {
       this.enableLog() && console.log("send:", this.name);
       const [serverName] = this.apiInstance.name.split(".");
       const axios2 = AxiosInstanceMap.get(serverName);
       if (!axios2) throw new Error("AxiosInstance not created");
-      const serverStatusCodeRule = ServerStatusCodeRuleMap.get(serverName);
-      const strategies = this.getStrategies();
-      this.Request = await applyStrategies(this.Request, strategies, "request");
-      this.Request = this.applyProgress(this.Request);
-      const { data, querys, params } = buildRequestArgs(
-        this.target,
-        this.propertyKey,
-        this.Args
-      );
-      this.enableLog() && console.log("methodUrl:", this.Request.baseURL, this.Request.url);
-      const newUrl = replacePlaceholders(this.Url, params);
-      this.Request = {
-        ...this.Request,
-        url: newUrl,
-        params: {
-          ...this.Request.params,
-          ...querys
-        },
-        data
-      };
-      this.enableLog() && console.log("request:", this.Request);
-      const isNoCache = this.isNoCache();
-      this.enableLog() && console.log("method is noCache:", isNoCache);
-      if (!isNoCache) {
-        const { data: data2 } = await this.getCacheData(serverName);
-        this.enableLog() && console.log("getCacheData:", data2);
-        if (data2) {
-          this.emit("hitCache", data2);
-          this.emit("success", data2);
-          this.emit("finish", data2);
-          return data2;
-        }
-      }
-      const requester = AxiosInstanceMap.get(serverName);
-      if (!requester) throw new Error("AxiosInstance not created");
-      try {
-        const rawResponse = await requester.request(this.Request);
-        const isSpecial = isSpecialResponse(rawResponse);
-        const response = await applyStrategies(
-          rawResponse,
-          strategies,
-          "response"
+      return new Promise(async (resolve, reject) => {
+        const serverStatusCodeRule = ServerStatusCodeRuleMap.get(serverName);
+        const strategies = this.getStrategies();
+        this.Request = await applyStrategies(this.Request, strategies, "request");
+        this.Request = this.applyProgress(this.Request);
+        const { data, querys, params } = buildRequestArgs(
+          this.target,
+          this.propertyKey,
+          // this.Args
+          args
         );
+        this.enableLog() && console.log("methodUrl:", this.Request.baseURL, this.Request.url);
+        const newUrl = replacePlaceholders(this.Url, params);
+        this.Request = {
+          ...this.Request,
+          url: newUrl,
+          params: {
+            ...this.Request.params,
+            ...querys
+          },
+          data
+        };
+        this.enableLog() && console.log("request:", this.Request);
+        const isNoCache = this.isNoCache();
+        this.enableLog() && console.log("method is noCache:", isNoCache);
         if (!isNoCache) {
-          !isSpecial && await this.setCacheData(serverName, response);
-        }
-        this.Response = response;
-        this.applyHitSource(serverName);
-        isSpecial && console.log("isSpecial:", isSpecial);
-        if (isSpecial) {
-          this.emit("success", response.data);
-          this.emit("finish", response.data);
-          return response;
+          const { data: data2 } = await this.getCacheData(serverName);
+          this.enableLog() && console.log("getCacheData:", data2);
+          if (data2) {
+            this.EventEmit.emit("hitCache", data2);
+            this.EventEmit.emit("success", data2);
+            this.EventEmit.emit("finish", data2);
+            resolve(data2);
+            return;
+          }
         }
-        !isSpecial && console.log("isSpecial:", isSpecial);
-        if (serverStatusCodeRule) {
-          const { key, rule } = serverStatusCodeRule;
-          const statuCodeKey = key ?? "code";
-          const data2 = response.data;
-          if (rule(data2[statuCodeKey])) {
-            this.emit("success", response.data);
-          } else {
-            this.emit("error", response.data);
+        const requester = AxiosInstanceMap.get(serverName);
+        if (!requester) throw new Error("AxiosInstance not created");
+        try {
+          const rawResponse = await requester.request(this.Request);
+          const isSpecial = isSpecialResponse(rawResponse);
+          const response = await applyStrategies(
+            rawResponse,
+            strategies,
+            "response"
+          );
+          if (!isNoCache) {
+            !isSpecial && await this.setCacheData(serverName, response);
+          }
+          this.Response = response;
+          this.applyHitSource(serverName);
+          isSpecial && console.log("isSpecial:", isSpecial);
+          if (isSpecial) {
+            this.EventEmit.emit("success", response.data);
+            this.EventEmit.emit("finish", response.data);
+            resolve(response);
+            return;
           }
+          !isSpecial && console.log("isSpecial:", isSpecial);
+          if (serverStatusCodeRule) {
+            const { key, rule } = serverStatusCodeRule;
+            const statuCodeKey = key ?? "code";
+            const data2 = response.data;
+            if (rule(data2[statuCodeKey])) {
+              this.EventEmit.emit("success", response.data);
+            } else {
+              this.EventEmit.emit("error", response.data);
+            }
+          }
+          resolve(response.data);
+        } catch (error) {
+          this.EventEmit.emit("error", error);
+          this.EventEmit.emit("finish", error);
+          console.error(error);
+          this.Error = error;
+          reject(error);
+          return;
         }
-        return response.data;
-      } catch (error) {
-        this.emit("error", error);
-        this.emit("finish", error);
-        console.error(error);
-        this.Error = error;
-        return error;
-      }
-    });
-    __publicField(this, "onSuccess", (handler) => {
-      this.on("success", handler);
-    });
-    __publicField(this, "onError", (handler) => {
-      this.on("error", handler);
+      });
     });
-    __publicField(this, "onHitCache", (handler) => {
-      this.on("hitCache", handler);
+    __publicField(this, "onSuccess", (listener) => {
+      this.EventEmit.on("success", listener);
     });
-    __publicField(this, "onFinish", (handler) => {
-      this.on("finish", handler);
+    __publicField(this, "onError", (listener) => {
+      this.EventEmit.on("error", listener);
     });
-    __publicField(this, "on", (eventName, handler) => {
-      if (typeof handler !== "function") {
-        throw new TypeError("Handler must be a function");
-      }
-      const handlers = this.eventMap.get(eventName) || /* @__PURE__ */ new Set();
-      handlers.add(handler);
-      this.eventMap.set(eventName, handlers);
+    __publicField(this, "onHitCache", (listener) => {
+      this.EventEmit.on("hitCache", listener);
     });
-    __publicField(this, "once", (eventName, handler) => {
-      const onceHandler = (data) => {
-        try {
-          handler.apply(this, [data]);
-        } finally {
-          this.off(eventName, onceHandler);
-          this.onceWrapperMap.delete(handler);
-        }
-      };
-      this.onceWrapperMap.set(handler, onceHandler);
-      this.on(eventName, onceHandler);
-    });
-    __publicField(this, "emit", (eventName, ...args) => {
-      const handlers = this.eventMap.get(eventName);
-      if (!handlers || handlers.size === 0) return false;
-      handlers.forEach((handler) => {
-        Promise.resolve().then(() => {
-          handler.apply(this, args);
-        });
-      });
-      return true;
-    });
-    __publicField(this, "off", (eventName, handler) => {
-      const handlers = this.eventMap.get(eventName);
-      if (!handlers) return;
-      if (handlers.has(handler)) {
-        handlers.delete(handler);
-      }
-      if (handlers.size === 0) {
-        this.eventMap.delete(eventName);
-      }
+    __publicField(this, "onFinish", (listener) => {
+      this.EventEmit.on("finish", listener);
     });
     __publicField(this, "registerStrategies", (...strategys) => {
       this.strategies.push(...strategys);
@@ -4174,25 +4171,20 @@ class SnailMethod {
     this.apiInstance = apiInstance;
     this.target = target;
     this.propertyKey = propertyKey.toString();
-    this.Args = args ?? [];
     this.init();
     this.enableLog() && console.log("url:", this.Url);
-    this.eventMap = /* @__PURE__ */ new Map();
-    this.onceWrapperMap = /* @__PURE__ */ new Map();
-    this.eventMap.set("success", /* @__PURE__ */ new Set());
-    this.eventMap.set("hitCache", /* @__PURE__ */ new Set());
-    this.eventMap.set("error", /* @__PURE__ */ new Set());
-    this.eventMap.set("finish", /* @__PURE__ */ new Set());
+    this.EventEmit = new SnailEvent();
   }
   init() {
     const methodOptions = this.getMethodOptions();
     if (!methodOptions) {
       throw new Error("Create SnailMethod must be used for decoration");
     }
-    const { path, method, name } = methodOptions;
+    const { path, method, name, adapter } = methodOptions;
     this.Name = name ?? this.propertyKey;
     this.Path = path;
     this.Method = method;
+    this.Adapter = adapter;
     this.createRequest();
     this.initUrl();
     this.initVersion();
@@ -4252,6 +4244,7 @@ class SnailMethod {
     const request = {
       url: this.Url,
       method: this.Method,
+      adapter: this.Adapter,
       timeout: this.apiInstance.timeout,
       data: {},
       params: {},
@@ -4336,12 +4329,11 @@ class SnailMethod {
     const [serverName] = this.apiInstance.name.split(".");
     const cacheForMap = CacheForMap.get(serverName);
     let flag = false;
-    if (typeof cacheForMap === "string" && (cacheForMap.toLowerCase() === "all" || cacheForMap === this.Method)) {
-      flag = true;
-    }
-    if (Array.isArray(cacheForMap)) {
-      flag = cacheForMap.includes(this.Method);
+    if (cacheForMap) {
+      flag = cacheForMap.includes(this.Method.toLowerCase());
     }
+    this.enableLog() && console.log("cacheForMap:", cacheForMap);
+    this.enableLog() && console.log("cacheMethodFlag:", flag);
     const isMethodNoCache = Reflect.getMetadata(
       NO_CACHE_KEY,
       this.target,
@@ -4499,10 +4491,8 @@ class SnailServer {
           propertyKey
         );
         if (!methodConfig) return target[propertyKey];
-        return (...args) => {
-          const method = new SnailMethod(apiInstance, target, propertyKey, [
-            ...args
-          ]);
+        return () => {
+          const method = new SnailMethod(apiInstance, target, propertyKey);
           this.initExpireSource(method, propertyKey);
           return method;
         };
@@ -4525,7 +4515,14 @@ class SnailServer {
       CacheTtlMap.set(this.Name, options.ttl || 500);
     }
     if (cacheFor) {
-      CacheForMap.set(this.Name, cacheFor);
+      if (Array.isArray(cacheFor)) {
+        CacheForMap.set(
+          this.Name,
+          cacheFor.map((method) => method.toLowerCase())
+        );
+        return;
+      }
+      CacheForMap.set(this.Name, [cacheFor.toLowerCase()]);
     }
   }
   initExpireSource(target, propertyKey) {
@@ -4596,6 +4593,12 @@ class SnailServer {
     return this.BaseURL;
   }
 }
+const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
+const Api = (url = "", config) => {
+  return (target) => {
+    Reflect.defineMetadata(API_CONFIG_KEY, { url, ...config }, target);
+  };
+};
 class SnailApi {
   constructor(options) {
     __publicField(this, "Name");
@@ -4820,7 +4823,6 @@ export {
   CacheType,
   Data,
   Delete,
-  EventType,
   Get,
   Head,
   HitSource,
@@ -4833,7 +4835,6 @@ export {
   Post,
   Put,
   Query,
-  RequestMethodEnum,
   Server,
   SnailApi,
   SnailMethod,