@snail-js/api 0.1.14 → 0.1.15

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

@@ -0,0 +1,16 @@
+import { RequestMethod } from "./request.method";
+import { SnailServer } from "../core";
+export interface ApiOptions {
+    name?: string;
+    timeout?: number;
+    version?: string;
+}
+export interface MethodOption {
+    name?: string;
+    method: RequestMethod;
+    path: string;
+}
+export interface ApiInstanceOptions {
+    serverInstance: SnailServer;
+    enableLog?: boolean;
+}

package/dist/typings/apiProxy.d.ts

@@ -1,11 +1,12 @@
-import { ResponseData } from "./response.data";
+import { ResponseData, ResponseJsonData, SpecialResponseData, StandardResponseData } from "./response.data";
+import { SnailMethod } from "../core/snailMethod";
 export type ApiResponse<T> = Promise<{
     data: T | null;
     error: Error | null;
     hitCache?: boolean;
 }>;
-export type ApiProxy<T, R extends {} = ResponseData, DK extends string = "data"> = {
-    [K in keyof T]: T[K] extends (...args: infer A) => any ? <D = any>(...args: A) => ApiResponse<R & {
-        [KK in DK]: D;
+export type ApiProxy<T extends object, RT extends ResponseData = StandardResponseData<ResponseJsonData>, DK extends string = "data"> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => any ? RT extends SpecialResponseData ? <RD>(...args: A) => SnailMethod<RD extends SpecialResponseData ? RD : never> : <RD>(...args: A) => RD extends SpecialResponseData ? SnailMethod<RD> : SnailMethod<RT & {
+        [KK in DK]: RD;
     }> : T[K];
 };

package/dist/typings/cache.management.option.d.ts

@@ -1,19 +1,25 @@
+import { AdapterConstructor } from "./cache.type";
 export declare enum CacheType {
     Memory = 0,
     IndexDB = 1,
-    LocalStorage = 2
+    LocalStorage = 2,
+    Custom = 3
 }
-interface MemoryCacheOption {
+export type MemoryCacheOption = {
     type: CacheType.Memory;
-}
-interface IndexDBCacheOption {
+} & CacheCommonOption;
+export type IndexDBCacheOption = {
     type: CacheType.IndexDB;
-}
-interface LocalStorageCacheOption {
+} & CacheCommonOption;
+export type LocalStorageCacheOption = {
     type: CacheType.LocalStorage;
-}
-interface CacheCommonOption {
+} & CacheCommonOption;
+export type CustomCacheOption = {
+    type: CacheType.Custom;
+    adapter: AdapterConstructor;
+    options?: any;
+} & CacheCommonOption;
+export interface CacheCommonOption {
     ttl?: number;
 }
-export type CacheManagementOption = CacheCommonOption & (MemoryCacheOption | IndexDBCacheOption | LocalStorageCacheOption);
-export {};
+export type CacheManagementOption = MemoryCacheOption | IndexDBCacheOption | LocalStorageCacheOption | CustomCacheOption;

package/dist/typings/cache.type.d.ts

@@ -1,8 +1,23 @@
 import MemoryCache from "../cache/memoryCache";
 import LocalStorageCache from "../cache/localstorageCache";
 import IndexDBCache from "../cache/indexDBCache";
-export interface CacheData<T = any> {
+export interface CacheSetData<T = any> {
     data: T;
     exp: number;
 }
-export type CacheStorage = MemoryCache | LocalStorageCache | IndexDBCache;
+export type CacheGetData<T = any> = {
+    error: null;
+    data: T;
+} | {
+    error: Error | Event;
+    data: null;
+};
+export type CacheStorage = MemoryCache | LocalStorageCache | IndexDBCache | CacheStorageAdapter;
+export declare abstract class CacheStorageAdapter {
+    abstract get<T = any>(key: string): Promise<CacheGetData<T>>;
+    abstract set<T = any>(key: string, value: CacheSetData<T>): Promise<boolean>;
+    abstract delete(key: string): Promise<boolean>;
+    abstract clear(): Promise<boolean>;
+    abstract keys(): Promise<string[]>;
+}
+export type AdapterConstructor = new (options?: any) => CacheStorageAdapter;

package/dist/typings/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./request.body";
 export * from "./request.method";
 export * from "./snail.option";
-export * from "./api.config";
+export * from "./api.option";
 export * from "./versioning.option";
 export * from "./cache.management.option";
 export * from "./cache.type";
@@ -9,3 +9,4 @@ export * from "./response.data";
 export * from "./strategy";
 export * from "./apiProxy";
 export * from "./sse";
+export * from "./snail.method";

package/dist/typings/request.method.d.ts

@@ -1,9 +1,10 @@
-export declare enum RequestMethod {
-    GET = "GET",
-    HEAD = "HEAD",
-    POST = "POST",
-    PUT = "PUT",
-    DELETE = "DELETE",
-    PATCH = "PATCH",
-    OPTIONS = "OPTIONS"
+export declare enum RequestMethodEnum {
+    GET = "Get",
+    HEAD = "Head",
+    POST = "Post",
+    PUT = "Put",
+    DELETE = "delete",
+    PATCH = "Patch",
+    OPTIONS = "Options"
 }
+export type RequestMethod = Uppercase<`${RequestMethodEnum}`> | Lowercase<`${RequestMethodEnum}`> | `${RequestMethodEnum}` | RequestMethodEnum;

package/dist/typings/response.data.d.ts

@@ -4,7 +4,11 @@ export interface PaginationData<T> {
     size: number;
     record: T[];
 }
-export interface ResponseData {
-    code: 0;
+export type ResponseJsonData = Record<string, any> | object;
+export type SpecialResponseData = string | ArrayBuffer | Blob | FormData;
+export type StandardResponseData<T extends ResponseJsonData = Record<string, any>> = {
+    code: number;
     message: string;
-}
+    data: T;
+};
+export type ResponseData = ResponseJsonData | StandardResponseData | SpecialResponseData;

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

@@ -0,0 +1,11 @@
+import { AxiosResponse } from "axios";
+import { ResponseData, ResponseJsonData, StandardResponseData, SpecialResponseData } from "./response.data";
+export type EventHandler<T = any> = (data?: T) => void;
+export declare enum EventType {
+    Success = "success",
+    Error = "error",
+    hitCache = "hitCache",
+    Finish = "finish"
+}
+export type SnailMethodEventType = `${EventType}` | EventType | string;
+export type SendRequest<RD extends ResponseData = StandardResponseData<ResponseJsonData>> = () => Promise<RD extends SpecialResponseData ? AxiosResponse<RD> : RD>;

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

@@ -1,7 +1,11 @@
 import { CacheManagementOption } from "./cache.management.option";
+import { RequestMethod } from "./request.method";
+export type CacheForType = "All" | "all" | RequestMethod | RequestMethod[];
 export interface SnailOption {
+    name?: string;
     baseURL?: string;
-    CacheManage?: CacheManagementOption;
+    cacheManage?: CacheManagementOption;
+    cacheFor?: CacheForType;
     enableLog?: boolean;
     timeout?: number;
 }

package/dist/typings/sse.d.ts

@@ -4,8 +4,12 @@ export type SseProxy<T extends object> = {
         eventSource: EventSource;
     } : T[K];
 };
-export declare class RegisterSseEvent {
+export declare class SseEventListener {
     eventName: string;
     emit: (event: any) => any;
     options: boolean | AddEventListenerOptions;
 }
+export declare class SseOptions {
+    withCredentials?: boolean;
+    version?: string;
+}

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

@@ -22,8 +22,8 @@ export interface VersioningQueryOption extends VersioningCommonOption {
 export interface VersioningCustomOption extends VersioningCommonOption {
     type: VersioningType.Custom;
     extractor: (requestOptions: unknown) => {
-        url: string;
-        headers: Record<string, any>;
+        type: VersioningType;
+        result: string | Record<string, any>;
     };
 }
 export type VersioningOption = VersioningUriOption | VersioningHeaderOption | VersioningQueryOption | VersioningCustomOption;

package/dist/utils/function.d.ts

@@ -1,10 +1,31 @@
-export declare const apiKey: <T extends {
-    url: string;
-    method: string;
-    data?: any;
-    version?: string;
-    params?: Record<string, any>;
-    headers?: Record<string, any>;
-}>(apiInstance: T) => Promise<string>;
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+import { Strategy } from "../typings";
+export declare function generateCacheKey(methodName: string, version: string | undefined, request: AxiosRequestConfig): Promise<string>;
 export declare function generateShortUniqueHash(str: string): Promise<string>;
 export declare function recordToString(record: Record<string, any>): string;
+export declare function replacePlaceholders(route: string, values: {
+    [key: string]: any;
+}): string;
+export declare const resolveUrl: (url?: string) => string;
+export declare function applyStrategies<T extends "request">(data: AxiosRequestConfig, strategies: Array<new () => Strategy>, type: T): Promise<AxiosRequestConfig>;
+export declare function applyStrategies<T extends "response">(data: AxiosResponse, strategies: Array<new () => Strategy>, type: T): Promise<AxiosResponse>;
+/**
+ * 一个无用函数，避免tsc报错
+ */
+export declare const SnailPass: (...args: any) => void;
+interface IJson {
+    [key: string]: any;
+}
+interface IArgs {
+    params: IJson;
+    data: IJson;
+    querys: IJson;
+}
+export declare const buildRequestArgs: (target: any, propertyKey: string, args: any[]) => IArgs;
+/**
+ * 判断响应的数据类型是否为 application/json
+ * @param {AxiosResponse} response - Axios 的响应对象
+ * @returns {boolean} - 如果响应的数据类型是 application/json 则返回 true，否则返回 false
+ */
+export declare function isSpecialResponse(response: AxiosResponse): boolean;
+export {};

package/dist/versioning/index.d.ts

@@ -0,0 +1 @@
+export * from './versioning';

package/dist/versioning/versioning.d.ts

@@ -1,7 +1,12 @@
-import { VersioningOption } from "../typings";
+import { VersioningType, VersioningOption } from "../typings";
 export interface VersioningResult {
-    url?: string;
-    headers?: Record<string, any>;
-    params?: Record<string, any>;
+    type: VersioningType;
+    result: string | Record<string, any>;
 }
-export declare function applyVersioning(version: string, versioning: VersioningOption): VersioningResult;
+/**
+ *
+ * @param version 版本号
+ * @param serverInstance 当前Server的实例
+ * @returns serverInstance上未配置版本管理器返回undefined, 否则返回版本管理器的结果
+ */
+export declare function applyVersioning(version: string, versioning: VersioningOption): VersioningResult | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snail-js/api",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Http Request with Decorators Api, build on axios",
   "type": "module",
   "main": "./src/index.ts",
@@ -30,6 +30,7 @@
   },
   "files": [
     "README.md",
+    "README_EN.md",
     "dist"
   ],
   "dependencies": {

package/dist/core/snail.d.ts

@@ -1,32 +0,0 @@
-import "reflect-metadata";
-import { Strategy, ApiProxy, SseProxy, ResponseData } from "../typings";
-export declare class Snail<R extends {} = ResponseData, DK extends string = "data"> {
-    private axiosInstance;
-    private strategies;
-    private cacheStorage?;
-    private version?;
-    private sourceMap;
-    private eventSource;
-    registerStrategy(strategy: Strategy): void;
-    createApi<T extends object>(constructor: new () => T): ApiProxy<T, R, DK>;
-    private buildRequestArgs;
-    private getStrategies;
-    private applyStrategies;
-    private applyVersion;
-    private getCache;
-    private initCacheManage;
-    private getHitSource;
-    private setHitSource;
-    private setCache;
-    private expireCache;
-    private getServerConfig;
-    private getApiConfig;
-    private initAxios;
-    private generateSseUrl;
-    private handleResponse;
-    private handleError;
-    createSse<T extends object>(constructor: new () => T): SseProxy<T>;
-    private initSse;
-    private setSse;
-    private registerSseEvent;
-}

package/dist/typings/api.config.d.ts

@@ -1,9 +0,0 @@
-import { RequestMethod } from "./request.method";
-export interface ApiConfig {
-    timeout?: number;
-    version?: string;
-}
-export interface MethodOption {
-    method: RequestMethod;
-    path: string;
-}