@snail-js/api 0.1.2 → 0.1.4

package/dist/snail-api.js

@@ -3682,6 +3682,13 @@ var CacheType = /* @__PURE__ */ ((CacheType2) => {
 })(CacheType || {});
 class Strategy {
 }
+class RegisterSseEvent {
+  constructor() {
+    __publicField(this, "eventName");
+    __publicField(this, "emit");
+    __publicField(this, "options");
+  }
+}
 function createCache(type, ttl) {
   if (type === CacheType.Memory) {
     return new MemoryCache(ttl);
@@ -3741,8 +3748,8 @@ function applyVersioning(version, versioning) {
     versioning
   );
 }
-const METHOD_KEY = "SNAIL_METHOD_KEY";
-const API_CONFIG_KEY = "SNAIL_API_CONFIG_KEY";
+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);
@@ -3766,7 +3773,7 @@ const Delete = createMethodDecorator(RequestMethod.DELETE);
 const Patch = createMethodDecorator(RequestMethod.PATCH);
 const Options = createMethodDecorator(RequestMethod.OPTIONS);
 const Head = createMethodDecorator(RequestMethod.HEAD);
-const SERVER_CONFIG_KEY = "SANIL_SERVER_CONFIG_KEY";
+const SERVER_CONFIG_KEY = Symbol("SANIL_SERVER_CONFIG_KEY");
 const Server = (config) => {
   return (target) => {
     Reflect.defineMetadata(SERVER_CONFIG_KEY, config, target);
@@ -3781,7 +3788,7 @@ const UseStrategy = (...strategies) => {
 };
 const REQUEST_ARGS_KEY = Symbol("SNAIL_REQUEST_ARGS_KEY");
 const Params = (key) => createArgsDecorator("params", key);
-const Data = () => createArgsDecorator("data");
+const Data = (key) => createArgsDecorator("data", key);
 const createArgsDecorator = (type, key) => {
   return (target, propertyKey, parameterIndex) => {
     const args = Reflect.getMetadata(REQUEST_ARGS_KEY, target, propertyKey) || [];
@@ -3801,11 +3808,50 @@ const Version = (version) => {
     Reflect.defineMetadata(VERSION_KEY, version, target, propertyKey);
   };
 };
-const CACHE_KEY = "SNALI_CACHE_KEY";
-const Cache = (options) => {
+const CACHE_OPTIONS_KEY = Symbol("SNALI_CACHE_OPTIONS_KEY");
+const Cache = (hitSource) => {
+  return (target, propertyKey) => {
+    const key = propertyKey ? `${CACHE_OPTIONS_KEY.toString()}_${propertyKey}` : CACHE_OPTIONS_KEY;
+    Reflect.defineMetadata(key, hitSource, target);
+  };
+};
+const UPLOAD_PROGRESS_KEY = Symbol("SNAIL_UPLOAD_PROGRESS_KEY");
+const EVENT_SOURCE_OPTION_KEY = Symbol("SNAIL_EVENT_SOURCE_OPTION_KEY");
+const Sse = (path, options) => {
   return (target, propertyKey) => {
-    const key = propertyKey ? `${CACHE_KEY}_${propertyKey}` : CACHE_KEY;
-    Reflect.defineMetadata(key, options, target);
+    Reflect.defineMetadata(
+      EVENT_SOURCE_OPTION_KEY,
+      {
+        path,
+        withCredentials: options == null ? void 0 : options.withCredentials
+      },
+      target,
+      propertyKey
+    );
+  };
+};
+const EVENT_SOURCE_EVENTS_KEY = Symbol("EVENT_SOURCE_EVENTS_KEY");
+const SseEvent = (eventName, options) => {
+  return (target, propertyKey) => {
+    const events = Reflect.getMetadata(EVENT_SOURCE_EVENTS_KEY, target) || [];
+    events.push({
+      eventName: eventName ? eventName : "message",
+      emit: target[propertyKey],
+      options
+    });
+    Reflect.defineMetadata(EVENT_SOURCE_EVENTS_KEY, events, target);
+  };
+};
+const EVENT_SOURCE_OPEN_KEY = Symbol("EVENT_SOURCE_OPEN_KEY");
+const OnSseOpen = () => {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(EVENT_SOURCE_OPEN_KEY, target[propertyKey], target);
+  };
+};
+const EVENT_SOURCE_ERROR_KEY = Symbol("EVENT_SOURCE_ERROR_KEY");
+const OnSseError = () => {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(EVENT_SOURCE_ERROR_KEY, target[propertyKey], target);
   };
 };
 class Snail {
@@ -3815,39 +3861,26 @@ class Snail {
     __publicField(this, "strategies", []);
     __publicField(this, "cacheStorage");
     __publicField(this, "version");
+    __publicField(this, "sourceMap", /* @__PURE__ */ new Map());
+    __publicField(this, "eventSource");
   }
   registerStrategy(strategy) {
     this.strategies.push(strategy);
   }
   createApi(constructor) {
     const instance = new constructor();
-    const serverConfig = Reflect.getMetadata(
-      SERVER_CONFIG_KEY,
-      this.constructor
-    );
-    console.log("serverConfig:", serverConfig);
-    if (!this.axiosInstance) {
-      this.axiosInstance = axios.create({
-        baseURL: serverConfig.baseURL,
-        timeout: serverConfig.timeout
-      });
-    }
-    const cacheManage = Reflect.getMetadata(
-      CACHE_KEY,
-      this
-    );
-    if (!this.cacheStorage && cacheManage !== void 0) {
-      this.cacheStorage = createCache(cacheManage.type, cacheManage.ttl || 300);
-    }
-    const apiConfig = Reflect.getMetadata(
-      API_CONFIG_KEY,
-      constructor
-    );
-    console.log("ApiConfig:", apiConfig);
+    const serverConfig = this.getServerConfig();
+    const { baseURL, timeout, CacheManage, enableLog } = serverConfig;
+    enableLog && console.log("serverConfig:", serverConfig);
+    this.initAxios({ baseURL, timeout });
+    enableLog && console.log("CacheManage:", CacheManage);
+    this.initCacheManage(CacheManage);
+    const apiConfig = this.getApiConfig(constructor);
+    enableLog && console.log("ApiConfig:", apiConfig);
     this.version = apiConfig.version;
     return new Proxy(instance, {
       get: (target, propertyKey) => {
-        console.log("proxy:", target, "|", propertyKey);
+        enableLog && console.log("proxy:", target, "|", propertyKey);
         if (typeof propertyKey !== "string") return;
         const methodConfig = Reflect.getMetadata(
           METHOD_KEY,
@@ -3857,7 +3890,7 @@ class Snail {
         if (!methodConfig) return target[propertyKey];
         return async (...args) => {
           const url = methodConfig.path == "" ? apiConfig.url : apiConfig.url + `/${methodConfig.path}`;
-          console.log("url:", url);
+          enableLog && console.log("url:", url);
           let request = {
             // baseURL: serverConfig.baseURL,
             url,
@@ -3868,35 +3901,11 @@ class Snail {
             ...request,
             ...this.applyVersion(request, target, propertyKey)
           };
-          console.log("版本管理参数:", request);
+          enableLog && console.log("版本管理参数:", request);
           const strategies = this.getStrategies(target, propertyKey);
-          const methodCache = this.getCacheConfig(target, propertyKey) || void 0;
-          if (methodCache == void 0) {
-            const cached = await this.applyCache(request, cacheManage);
-            if (cached && cached.error === null) {
-              let cacheResponse = {
-                data: cached.data,
-                status: 304,
-                headers: {
-                  hitCache: true
-                },
-                statusText: "get response data from cache",
-                config: { headers: new AxiosHeaders2() }
-              };
-              const responseStrategies = strategies.filter(
-                (strategy) => strategy.applyResponse
-              );
-              const strategyResponse = await this.applyStrategies(
-                cacheResponse,
-                responseStrategies,
-                "response"
-              );
-              return strategyResponse;
-            }
-          }
           const params = this.buildRequestArgs(target, propertyKey, args);
           request = { ...request, ...params };
-          console.log("构建请求参数：", request);
+          enableLog && console.log("构建请求参数：", request);
           const requestStrategies = strategies.filter(
             (strategy) => strategy.applyRequest
           );
@@ -3905,10 +3914,32 @@ class Snail {
             requestStrategies,
             "request"
           );
+          const hitSource = this.getHitSource(target, propertyKey);
+          enableLog && console.log("hitSource:", hitSource);
+          if (typeof hitSource == "string") {
+            this.setHitSource(request, hitSource);
+          }
+          if (hitSource !== null) {
+            const cachedResponse = await this.getCache(request, strategies);
+            if (cachedResponse) {
+              enableLog && console.warn("数据从缓存获取");
+              return this.handleResponse(cachedResponse, true);
+            }
+          }
+          const onUploadProgress = Reflect.getMetadata(
+            UPLOAD_PROGRESS_KEY,
+            target,
+            propertyKey
+          );
           try {
-            console.log("send request:", request);
-            const response = await this.axiosInstance(request);
-            return this.handleResponse(response);
+            enableLog && console.log("send request:", request);
+            const response = await this.axiosInstance({
+              ...request,
+              onUploadProgress
+            });
+            hitSource !== null && this.setCache(request, response);
+            this.expireCache(propertyKey);
+            return this.handleResponse(response, false);
           } catch (error) {
             return this.handleError(error);
           }
@@ -3919,7 +3950,6 @@ class Snail {
   buildRequestArgs(target, propertyKey, args) {
     const requestArgs = { params: {}, data: {} };
     const paramConfigs = Reflect.getMetadata(REQUEST_ARGS_KEY, target, propertyKey) || [];
-    console.log("请求参数:", paramConfigs);
     paramConfigs.forEach(({ index, type, key }) => {
       const value = args[index];
       if (type === "params" && !key && typeof value === "object") {
@@ -3939,14 +3969,11 @@ class Snail {
   }
   getStrategies(target, propertyKey) {
     const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
-    console.log("serverStrategies:", serverStrategies);
     const classStrategies = Reflect.getMetadata(STRATEGY_KEY, target.constructor) || [];
-    console.log("classStrategies:", classStrategies);
     const methodStrategies = Reflect.getMetadata(
       `${STRATEGY_KEY.toString()}_${propertyKey}`,
       target
     ) || [];
-    console.log("methodStrategies:", methodStrategies);
     const allStrategies = [
       ...this.strategies,
       ...serverStrategies,
@@ -3967,7 +3994,6 @@ class Snail {
       VERSIONING_KEY,
       this.constructor
     );
-    console.log("版本管理器：", versioning);
     if (!versioning) return request;
     const version = Reflect.getMetadata(VERSION_KEY, target, propertyKey);
     const currentVersion = version || this.version || versioning.defaultVersion;
@@ -3978,24 +4004,104 @@ class Snail {
     const versionUrl = url ? `${url}/${request.url}` : request.url;
     return { ...request, url: versionUrl, headers, params };
   }
-  async applyCache(request, options) {
+  async getCache(request, strategies) {
     var _a;
+    if (!this.cacheStorage) return void 0;
     const cacheKey = apiKey(request);
-    if (this.cacheStorage) {
-      return await ((_a = this.cacheStorage) == null ? void 0 : _a.get(cacheKey));
+    const cached = await ((_a = this.cacheStorage) == null ? void 0 : _a.get(cacheKey));
+    if (cached && cached.error === null) {
+      let cacheResponse = {
+        data: cached.data,
+        status: 304,
+        headers: {},
+        statusText: "get response data from cache",
+        config: { headers: new AxiosHeaders2() }
+      };
+      const responseStrategies = strategies.filter(
+        (strategy) => strategy.applyResponse
+      );
+      const strategyResponse = await this.applyStrategies(
+        cacheResponse,
+        responseStrategies,
+        "response"
+      );
+      return strategyResponse;
     }
-    return void 0;
   }
-  getCacheConfig(target, propertyKey) {
-    return Reflect.getMetadata(`${CACHE_KEY.toString()}_${propertyKey}`, target) || // 方法级
-    Reflect.getMetadata(CACHE_KEY, target.constructor);
+  initCacheManage(options) {
+    if (!this.cacheStorage && options !== void 0) {
+      this.cacheStorage = createCache(options.type, options.ttl || 300);
+    }
   }
-  handleResponse(response) {
-    console.log("Response:", response);
+  getHitSource(target, propertyKey) {
+    const methodHitSource = Reflect.getMetadata(
+      `${CACHE_OPTIONS_KEY.toString()}_${propertyKey}`,
+      target
+    );
+    if (methodHitSource !== void 0) return methodHitSource;
+    const apiHitSource = Reflect.getMetadata(
+      CACHE_OPTIONS_KEY,
+      target.constructor
+    );
+    return apiHitSource;
+  }
+  setHitSource(request, hitSource) {
+    const cacheKeys = this.sourceMap.get(hitSource);
+    const currentCacheKey = apiKey(request);
+    if (cacheKeys) {
+      cacheKeys.push(currentCacheKey);
+      this.sourceMap.set(hitSource, cacheKeys);
+    } else {
+      this.sourceMap.set(hitSource, [currentCacheKey]);
+    }
+  }
+  async setCache(request, response) {
+    var _a;
+    const cacheKey = apiKey(request);
+    await ((_a = this.cacheStorage) == null ? void 0 : _a.set(cacheKey, response.data));
+  }
+  async expireCache(hitSource) {
+    const keys = this.sourceMap.get(hitSource);
+    if (keys) {
+      Promise.all(
+        keys.map(async (key) => {
+          var _a;
+          await ((_a = this.cacheStorage) == null ? void 0 : _a.delete(key));
+        })
+      );
+    }
+  }
+  getServerConfig() {
+    return Reflect.getMetadata(
+      SERVER_CONFIG_KEY,
+      this.constructor
+    );
+  }
+  getApiConfig(constructor) {
+    return Reflect.getMetadata(API_CONFIG_KEY, constructor);
+  }
+  initAxios(config) {
+    if (!this.axiosInstance) {
+      this.axiosInstance = axios.create({
+        baseURL: config.baseURL,
+        timeout: config.timeout
+      });
+    }
+  }
+  generateSseUrl(baseURL, url) {
+    if (!baseURL && !url) {
+      return "/";
+    }
+    if (!baseURL && url) {
+      return `/${url}`;
+    }
+    return `${baseURL}/${url}`;
+  }
+  handleResponse(response, hitCache) {
     return {
       data: response.data,
       error: null,
-      hitCache: false
+      hitCache
     };
   }
   handleError(error) {
@@ -4004,33 +4110,99 @@ class Snail {
       error
     };
   }
+  createSse(constructor) {
+    const instance = new constructor();
+    const serverConfig = this.getServerConfig();
+    const { baseURL, enableLog } = serverConfig;
+    const apiConfig = this.getApiConfig(constructor);
+    enableLog && console.log("ApiConfig:", apiConfig);
+    this.version = apiConfig.version;
+    return new Proxy(instance, {
+      get: (target, propertyKey) => {
+        enableLog && console.log("proxy:", target, "|", propertyKey);
+        if (typeof propertyKey !== "string") return;
+        const sseOption = Reflect.getMetadata(
+          EVENT_SOURCE_OPTION_KEY,
+          target,
+          propertyKey
+        );
+        if (sseOption) {
+          const url = sseOption.path == "" ? apiConfig.url : apiConfig.url + `/${sseOption.path}`;
+          const { url: versionUrl } = this.applyVersion(
+            { url },
+            target,
+            propertyKey
+          );
+          const sseUrl = this.generateSseUrl(baseURL, versionUrl || url);
+          enableLog && console.log("sse-url:", sseUrl);
+          const { eventSource, close } = this.initSse(sseUrl, sseOption);
+          this.eventSource = eventSource;
+          this.setSse(target);
+          this.registerSseEvent(target);
+          return () => {
+            return { eventSource, close };
+          };
+        }
+      }
+    });
+  }
+  initSse(url, options) {
+    const eventSource = new EventSource(url, {
+      withCredentials: options.withCredentials ? options.withCredentials : false
+    });
+    console.log("EventSource:", eventSource);
+    return {
+      eventSource,
+      close: eventSource.close
+    };
+  }
+  setSse(target) {
+    const onOpenFunc = Reflect.getMetadata(EVENT_SOURCE_OPEN_KEY, target);
+    console.log("sse-proxy[open]:", onOpenFunc);
+    if (typeof onOpenFunc == "function") {
+      this.eventSource && (this.eventSource.onopen = onOpenFunc);
+    }
+    const onErrorFunc = Reflect.getMetadata(EVENT_SOURCE_ERROR_KEY, target);
+    console.log("sse-proxy[error]:", onErrorFunc);
+    if (typeof onErrorFunc == "function") {
+      this.eventSource && (this.eventSource.onerror = onErrorFunc);
+    }
+  }
+  registerSseEvent(target) {
+    const eventSource = this.eventSource;
+    if (!eventSource) return;
+    const events = Reflect.getMetadata(
+      EVENT_SOURCE_EVENTS_KEY,
+      target
+    );
+    events.map((event) => {
+      eventSource.addEventListener(event.eventName, event.emit, event.options);
+    });
+  }
 }
 export {
-  API_CONFIG_KEY,
   Api,
-  CACHE_KEY,
   Cache,
   CacheType,
   Data,
   Delete,
   Get,
   Head,
-  METHOD_KEY,
+  OnSseError,
+  OnSseOpen,
   Options,
   Params,
   Patch,
   Post,
   Put,
-  REQUEST_ARGS_KEY,
+  RegisterSseEvent,
   RequestMethod,
-  SERVER_CONFIG_KEY,
-  STRATEGY_KEY,
   Server,
   Snail,
+  Sse,
+  SseEvent,
   Strategy,
   UseStrategy,
-  VERSIONING_KEY,
-  VERSION_KEY,
   Version,
   Versioning,
   VersioningType,