@snail-js/api 0.1.2 → 0.1.4

package/dist/snail-api.umd.cjs

@@ -3686,6 +3686,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   })(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);
@@ -3745,8 +3752,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       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);
@@ -3770,7 +3777,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   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);
@@ -3785,7 +3792,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   };
   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) || [];
@@ -3805,11 +3812,50 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       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 {
@@ -3819,39 +3865,26 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __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,
@@ -3861,7 +3894,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           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,
@@ -3872,35 +3905,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               ...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 AxiosHeaders() }
-                };
-                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
             );
@@ -3909,10 +3918,32 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               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);
             }
@@ -3923,7 +3954,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     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") {
@@ -3943,14 +3973,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     }
     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,
@@ -3971,7 +3998,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         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;
@@ -3982,24 +4008,104 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       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 AxiosHeaders() }
+        };
+        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) {
@@ -4008,32 +4114,98 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         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);
+      });
+    }
   }
-  exports2.API_CONFIG_KEY = API_CONFIG_KEY;
   exports2.Api = Api;
-  exports2.CACHE_KEY = CACHE_KEY;
   exports2.Cache = Cache;
   exports2.CacheType = CacheType;
   exports2.Data = Data;
   exports2.Delete = Delete;
   exports2.Get = Get;
   exports2.Head = Head;
-  exports2.METHOD_KEY = METHOD_KEY;
+  exports2.OnSseError = OnSseError;
+  exports2.OnSseOpen = OnSseOpen;
   exports2.Options = Options;
   exports2.Params = Params;
   exports2.Patch = Patch;
   exports2.Post = Post;
   exports2.Put = Put;
-  exports2.REQUEST_ARGS_KEY = REQUEST_ARGS_KEY;
+  exports2.RegisterSseEvent = RegisterSseEvent;
   exports2.RequestMethod = RequestMethod;
-  exports2.SERVER_CONFIG_KEY = SERVER_CONFIG_KEY;
-  exports2.STRATEGY_KEY = STRATEGY_KEY;
   exports2.Server = Server;
   exports2.Snail = Snail;
+  exports2.Sse = Sse;
+  exports2.SseEvent = SseEvent;
   exports2.Strategy = Strategy;
   exports2.UseStrategy = UseStrategy;
-  exports2.VERSIONING_KEY = VERSIONING_KEY;
-  exports2.VERSION_KEY = VERSION_KEY;
   exports2.Version = Version;
   exports2.Versioning = Versioning;
   exports2.VersioningType = VersioningType;

package/dist/typings/apiProxy.d.ts

@@ -5,7 +5,7 @@ export type ApiResponse<T> = Promise<{
 export type ApiProxy<T, R extends {
     data: any;
 }> = {
-    [K in keyof T]: T[K] extends (...args: infer A) => any ? <D = any, E = any>(...args: A) => ApiResponse<R & {
+    [K in keyof T]: T[K] extends (...args: infer A) => any ? <D = any>(...args: A) => ApiResponse<R & {
         data: D;
     }> : T[K];
 };

package/dist/typings/index.d.ts

@@ -8,3 +8,4 @@ export * from "./cache.type";
 export * from "./response.data";
 export * from "./strategy";
 export * from "./apiProxy";
+export * from "./sse";

package/dist/typings/snail.option.d.ts

@@ -1,8 +1,6 @@
 import { CacheManagementOption } from "./cache.management.option";
-import { VersioningOption } from "./versioning.option";
 export interface SnailOption {
     baseURL?: string;
-    Versioning?: VersioningOption;
     CacheManage?: CacheManagementOption;
     enableLog?: boolean;
     timeout?: number;

package/dist/typings/sse.d.ts

@@ -0,0 +1,11 @@
+export type SseProxy<T extends object> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => any ? () => {
+        sourceEvent: EventSource;
+        close: Function;
+    } : T[K];
+};
+export declare class RegisterSseEvent {
+    eventName: string;
+    emit: (event: any) => any;
+    options: boolean | AddEventListenerOptions;
+}

package/dist/versioning/versioning.d.ts

@@ -1,8 +1,7 @@
 import { VersioningOption } from "../typings";
-interface VersioningResult {
+export interface VersioningResult {
     url?: string;
     headers?: Record<string, any>;
     params?: Record<string, any>;
 }
 export declare function applyVersioning(version: string, versioning: VersioningOption): VersioningResult;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snail-js/api",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Http Request with Decorators Api, build on axios",
   "type": "module",
   "main": "./src/index.ts",