axios-annotations 2.3.0 → 3.0.0

package/wechat-mp/core/provider.js

@@ -0,0 +1,178 @@
+"use strict";
+var __awaiter = (void 0) && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var AxiosStaticInstanceProvider = /** @class */ function() {
+    function AxiosStaticInstanceProvider() {
+        this.__instance = null;
+    }
+    AxiosStaticInstanceProvider.prototype.provide = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            var lib;
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            Promise.resolve().then(function() {
+                                return require("axios");
+                            })
+                        ];
+                    case 1:
+                        lib = _a.sent();
+                        return [
+                            2 /*return*/ ,
+                            lib["default"]
+                        ];
+                }
+            });
+        });
+    };
+    AxiosStaticInstanceProvider.prototype.get = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            var _a;
+            return __generator(this, function(_b) {
+                switch(_b.label){
+                    case 0:
+                        if (this.__instance) {
+                            return [
+                                2 /*return*/ ,
+                                this.__instance
+                            ];
+                        }
+                        _a = this;
+                        return [
+                            4 /*yield*/ ,
+                            this.provide()
+                        ];
+                    case 1:
+                        _a.__instance = _b.sent();
+                        return [
+                            2 /*return*/ ,
+                            this.__instance
+                        ];
+                }
+            });
+        });
+    };
+    return AxiosStaticInstanceProvider;
+}();
+exports["default"] = AxiosStaticInstanceProvider;

package/wechat-mp/core/service.d.ts

@@ -0,0 +1,5 @@
+export default class Service {
+    config: import("./config").default;
+    path: string;
+    constructor();
+}

package/wechat-mp/core/service.js

@@ -0,0 +1,60 @@
+"use strict";
+var __values = (void 0) && (void 0).__values || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function next() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+var config_1 = require("./config");
+var Service = /** @class */ function() {
+    function Service() {
+        var e_1, _a;
+        this.config = config_1.config;
+        this.path = '';
+        var target = Object.getPrototypeOf(this);
+        // 获取被加入切面的方法
+        var methodsToBind = target.__decoratedMethods;
+        if (methodsToBind && Array.isArray(methodsToBind)) {
+            try {
+                for(var methodsToBind_1 = __values(methodsToBind), methodsToBind_1_1 = methodsToBind_1.next(); !methodsToBind_1_1.done; methodsToBind_1_1 = methodsToBind_1.next()){
+                    var methodName = methodsToBind_1_1.value;
+                    if (typeof this[methodName] === 'function') {
+                        this[methodName] = this[methodName].bind(this);
+                    }
+                }
+            } catch (e_1_1) {
+                e_1 = {
+                    error: e_1_1
+                };
+            } finally{
+                try {
+                    if (methodsToBind_1_1 && !methodsToBind_1_1.done && (_a = methodsToBind_1["return"])) _a.call(methodsToBind_1);
+                } finally{
+                    if (e_1) throw e_1.error;
+                }
+            }
+        }
+        if (target.__path) {
+            this.path = target.__path;
+        }
+        if (target.__config) {
+            this.config = target.__config;
+        }
+        Reflect.deleteProperty(target, '__path');
+        Reflect.deleteProperty(target, '__config');
+        Reflect.deleteProperty(target, '__decoratedMethods');
+    }
+    return Service;
+}();
+exports["default"] = Service;

package/wechat-mp/decorator/path-variables.d.ts

@@ -0,0 +1,7 @@
+import { ParamsMapping } from "../core/builder";
+import type Service from "../core/service";
+type PathVariablesParamsMapping = Omit<ParamsMapping, 'key'> & {
+    key?: string;
+};
+export default function PathVariables(keyOrMapping?: string | PathVariablesParamsMapping): <T extends Service>(_target: T, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export {};

package/wechat-mp/decorator/path-variables.js

@@ -0,0 +1,37 @@
+"use strict";
+var __assign = (void 0) && (void 0).__assign || function() {
+    __assign = Object.assign || function(t) {
+        for(var s, i = 1, n = arguments.length; i < n; i++){
+            s = arguments[i];
+            for(var p in s)if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = PathVariables;
+var common_1 = require("../core/common");
+function PathVariables(keyOrMapping) {
+    return function(_target, propertyKey, descriptor) {
+        var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+        var builder = metaDescriptor.builder;
+        if (builder) {
+            if (typeof keyOrMapping === 'string' || keyOrMapping === undefined || (0, common_1.isNullOrEmpty)(keyOrMapping)) {
+                builder.pathVariable({
+                    // key 为空使用数据源本体
+                    key: typeof keyOrMapping === 'string' ? keyOrMapping : '',
+                    required: false,
+                    value: undefined
+                });
+            } else {
+                builder.pathVariable(__assign(__assign({}, keyOrMapping), {
+                    key: typeof keyOrMapping.key === 'string' ? keyOrMapping.key : '',
+                    required: false
+                }));
+            }
+        }
+    };
+}

package/wechat-mp/decorator/request-body.d.ts

@@ -0,0 +1,7 @@
+import type Service from "../core/service";
+import { ParamsMapping } from "../core/builder";
+type RequestBodyParamsMapping = Omit<ParamsMapping, 'key'> & {
+    key?: string;
+};
+export default function RequestBody(keyOrMapping?: string | RequestBodyParamsMapping): <T extends Service>(_target: T, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export {};

package/wechat-mp/decorator/request-body.js

@@ -0,0 +1,36 @@
+"use strict";
+var __assign = (void 0) && (void 0).__assign || function() {
+    __assign = Object.assign || function(t) {
+        for(var s, i = 1, n = arguments.length; i < n; i++){
+            s = arguments[i];
+            for(var p in s)if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = RequestBody;
+var common_1 = require("../core/common");
+function RequestBody(keyOrMapping) {
+    return function(_target, propertyKey, descriptor) {
+        var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+        var builder = metaDescriptor.builder;
+        if (builder) {
+            if (typeof keyOrMapping === 'string' || keyOrMapping === undefined || (0, common_1.isNullOrEmpty)(keyOrMapping)) {
+                builder.body({
+                    key: typeof keyOrMapping === 'string' ? keyOrMapping : 'body',
+                    required: false,
+                    value: undefined
+                });
+            } else {
+                builder.body(__assign(__assign({}, keyOrMapping), {
+                    key: typeof keyOrMapping.key === 'string' ? keyOrMapping.key : 'body',
+                    required: false
+                }));
+            }
+        }
+    };
+}

package/wechat-mp/decorator/request-config.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosRequestConfig } from 'axios';
+import Config from "../core/config";
+import { AxiosConfigMapper } from "../core/builder";
+type ConfigType = Config | AxiosRequestConfig | AxiosConfigMapper;
+type Decorator<T> = T extends Config ? ClassDecorator : PropertyDecorator;
+export default function RequestConfig<T = ConfigType>(config: T): Decorator<T>;
+export {};

package/wechat-mp/decorator/request-config.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = RequestConfig;
+var config_1 = require("../core/config");
+var common_1 = require("../core/common");
+function RequestConfig(config) {
+    if (config instanceof config_1["default"]) {
+        // --- Class Decorator Logic ---
+        return function(constructor) {
+            var target = constructor.prototype;
+            if (config) {
+                Object.defineProperty(target, '__config', {
+                    value: config,
+                    enumerable: false,
+                    configurable: true,
+                    writable: false
+                });
+            }
+            return constructor;
+        };
+    } else {
+        // --- Method Decorator Logic ---
+        return function(target, propertyKey, descriptor) {
+            var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+            metaDescriptor.builder.config(config);
+        };
+    }
+}

package/wechat-mp/decorator/request-header.d.ts

@@ -0,0 +1,4 @@
+import type Service from "../core/service";
+import { ParamsMapping } from "../core/builder";
+export default function RequestHeader(mapping: ParamsMapping): (target: Service, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export default function RequestHeader(key: string, required?: boolean): (target: Service, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/wechat-mp/decorator/request-header.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = RequestHeader;
+var common_1 = require("../core/common");
+function RequestHeader(keyOrMapping, required) {
+    return function(_target, propertyKey, descriptor) {
+        var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+        var builder = metaDescriptor.builder;
+        if (builder) {
+            if (typeof keyOrMapping === 'string') {
+                builder.header(keyOrMapping, required === true);
+            } else {
+                builder.header(keyOrMapping);
+            }
+        }
+    };
+}

package/wechat-mp/decorator/request-mapping.d.ts

@@ -0,0 +1,6 @@
+import type { Method } from 'axios';
+import type Service from "../core/service";
+export default function RequestMapping(path: string): <T extends {
+    new (...args: any[]): Service;
+}>(constructor: T) => void;
+export default function RequestMapping(path: string, method: Method): (target: Service, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/wechat-mp/decorator/request-mapping.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = RequestMapping;
+var common_1 = require("../core/common");
+// Implementation
+function RequestMapping(path, method) {
+    if (method === undefined) {
+        // Class Decorator logic remains the same
+        return function(constructor) {
+            // 这里不用继承 extends constructor, 无法转换到 ES5
+            // 获取原型对象
+            var target = constructor.prototype;
+            if (path) {
+                Object.defineProperty(target, '__path', {
+                    value: path,
+                    enumerable: false,
+                    configurable: true,
+                    writable: false
+                });
+            }
+            return constructor;
+        };
+    } else {
+        // Method Decorator logic
+        return function(target, propertyKey, descriptor) {
+            // 在原型链上标记方法被替换，在 RequestConfig 中会重新绑定 this 指针。
+            // target 是类的原型对象
+            if (!Object.prototype.hasOwnProperty.call(target, '__decoratedMethods')) {
+                Object.defineProperty(target, '__decoratedMethods', {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                    writable: false
+                });
+            }
+            target.__decoratedMethods.push(propertyKey);
+            var originalMethod = descriptor.value;
+            var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+            // 这里没有使用箭头函数，this 运行时不确定 因此后续需要重新绑定
+            descriptor.value = function() {
+                var args = [];
+                for(var _i = 0; _i < arguments.length; _i++){
+                    args[_i] = arguments[_i];
+                }
+                try {
+                    var source = originalMethod.apply(this, args);
+                    var service = this;
+                    var usingConfig = metaDescriptor.config ? metaDescriptor.config : service.config;
+                    var servicePrefix = service.path;
+                    var requestPath = (0, common_1.normalizePath)("".concat(servicePrefix, "/").concat(path));
+                    return metaDescriptor.builder.buildWith(usingConfig, requestPath, method, source);
+                } catch (error) {
+                    console.error("Error in method '".concat(propertyKey, "'"), error);
+                    throw error;
+                }
+            };
+        };
+    }
+}

package/wechat-mp/decorator/request-param.d.ts

@@ -0,0 +1,4 @@
+import type Service from "../core/service";
+import { ParamsMapping } from "../core/builder";
+export default function RequestParam(mapping: ParamsMapping): (target: Service, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export default function RequestParam(key: string, required?: boolean): (target: Service, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/wechat-mp/decorator/request-param.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = RequestParam;
+var common_1 = require("../core/common");
+// 声明查询串参数
+function RequestParam(keyOrMapping, required) {
+    return function(_target, propertyKey, descriptor) {
+        var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+        var builder = metaDescriptor.builder;
+        if (builder) {
+            if (typeof keyOrMapping === 'string') {
+                builder.param(keyOrMapping, required === true);
+            } else {
+                builder.param(keyOrMapping);
+            }
+        }
+    };
+}

package/wechat-mp/decorator/request-with.d.ts

@@ -0,0 +1,3 @@
+import type Service from "../core/service";
+import Config from "../core/config";
+export default function RequestWith(config: Config): <T extends Service>(_target: T, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/wechat-mp/decorator/request-with.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports["default"] = RequestWith;
+var common_1 = require("../core/common");
+// 重定向方法的配置
+function RequestWith(config) {
+    return function(_target, propertyKey, descriptor) {
+        var metaDescriptor = (0, common_1.castToMetaDescriptor)(descriptor);
+        metaDescriptor.config = config;
+    };
+}

package/wechat-mp/index.d.ts

@@ -0,0 +1,13 @@
+export { default as Config } from "./core/config";
+export { config } from "./core/config";
+export { default as Expect } from "./core/expect";
+export { default as Service } from "./core/service";
+export { default as AxiosStaticInstanceProvider } from "./core/provider";
+export { default as RequestConfig } from "./decorator/request-config";
+export { default as RequestMapping } from "./decorator/request-mapping";
+export { default as RequestParam } from "./decorator/request-param";
+export { default as RequestBody } from "./decorator/request-body";
+export { default as RequestHeader } from "./decorator/request-header";
+export { default as RequestWith } from "./decorator/request-with";
+export { default as PathVariables } from "./decorator/path-variables";
+export { default as RequestBuilder } from "./core/builder";

package/wechat-mp/index.js

@@ -0,0 +1,97 @@
+"use strict";
+// noinspection JSUnusedGlobalSymbols
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.RequestBuilder = exports.PathVariables = exports.RequestWith = exports.RequestHeader = exports.RequestBody = exports.RequestParam = exports.RequestMapping = exports.RequestConfig = exports.AxiosStaticInstanceProvider = exports.Service = exports.Expect = exports.config = exports.Config = void 0;
+var config_1 = require("./core/config");
+Object.defineProperty(exports, "Config", {
+    enumerable: true,
+    get: function get() {
+        return config_1["default"];
+    }
+});
+var config_2 = require("./core/config");
+Object.defineProperty(exports, "config", {
+    enumerable: true,
+    get: function get() {
+        return config_2.config;
+    }
+});
+var expect_1 = require("./core/expect");
+Object.defineProperty(exports, "Expect", {
+    enumerable: true,
+    get: function get() {
+        return expect_1["default"];
+    }
+});
+var service_1 = require("./core/service");
+Object.defineProperty(exports, "Service", {
+    enumerable: true,
+    get: function get() {
+        return service_1["default"];
+    }
+});
+var provider_1 = require("./core/provider");
+Object.defineProperty(exports, "AxiosStaticInstanceProvider", {
+    enumerable: true,
+    get: function get() {
+        return provider_1["default"];
+    }
+});
+var request_config_1 = require("./decorator/request-config");
+Object.defineProperty(exports, "RequestConfig", {
+    enumerable: true,
+    get: function get() {
+        return request_config_1["default"];
+    }
+});
+var request_mapping_1 = require("./decorator/request-mapping");
+Object.defineProperty(exports, "RequestMapping", {
+    enumerable: true,
+    get: function get() {
+        return request_mapping_1["default"];
+    }
+});
+var request_param_1 = require("./decorator/request-param");
+Object.defineProperty(exports, "RequestParam", {
+    enumerable: true,
+    get: function get() {
+        return request_param_1["default"];
+    }
+});
+var request_body_1 = require("./decorator/request-body");
+Object.defineProperty(exports, "RequestBody", {
+    enumerable: true,
+    get: function get() {
+        return request_body_1["default"];
+    }
+});
+var request_header_1 = require("./decorator/request-header");
+Object.defineProperty(exports, "RequestHeader", {
+    enumerable: true,
+    get: function get() {
+        return request_header_1["default"];
+    }
+});
+var request_with_1 = require("./decorator/request-with");
+Object.defineProperty(exports, "RequestWith", {
+    enumerable: true,
+    get: function get() {
+        return request_with_1["default"];
+    }
+});
+var path_variables_1 = require("./decorator/path-variables");
+Object.defineProperty(exports, "PathVariables", {
+    enumerable: true,
+    get: function get() {
+        return path_variables_1["default"];
+    }
+});
+var builder_1 = require("./core/builder");
+Object.defineProperty(exports, "RequestBuilder", {
+    enumerable: true,
+    get: function get() {
+        return builder_1["default"];
+    }
+});

package/wechat-mp/plugins/auth/authorizer.d.ts

@@ -0,0 +1,24 @@
+import type { InternalAxiosRequestConfig, AxiosResponse } from 'axios';
+import SessionStorage from "./storage";
+import SessionHistory from "./history";
+import { BasicSession } from "./index";
+export default class Authorizer {
+    private _sessionKey;
+    private _sessionStorage;
+    private _sessionHistory;
+    get sessionKey(): string;
+    set sessionKey(value: string);
+    get sessionStorage(): SessionStorage;
+    set sessionStorage(value: SessionStorage);
+    get sessionHistory(): SessionHistory;
+    set sessionHistory(value: SessionHistory);
+    getSession(): Promise<any>;
+    storageSession(session: BasicSession | null): Promise<void>;
+    refreshSession(_session: BasicSession): Promise<any>;
+    withAuthentication(request: InternalAxiosRequestConfig, session: BasicSession): void;
+    checkSession(request: InternalAxiosRequestConfig, session: BasicSession): boolean;
+    checkResponse(response: AxiosResponse): boolean;
+    onAuthorizedDenied(error: unknown): Promise<void>;
+    onSessionInvalidated(): void;
+    invalidateSession(): Promise<void>;
+}