api-def 0.7.4 → 0.8.1

package/esm/ApiConstants.js

@@ -1,4 +1,4 @@
-export var RequestMethod = {
+export const RequestMethod = {
     /** @deprecated use 'POST' */
     Post: "post",
     /** @deprecated use 'GET' */
@@ -9,7 +9,7 @@ export var RequestMethod = {
     DELETE: "delete",
     PATCH: "patch",
 };
-export var RequestEvent = {
+export const RequestEvent = {
     /** @deprecated use 'BEFORE_SEND' */
     BeforeSend: "beforeSend",
     /** @deprecated use 'SUCCESS' */
@@ -23,7 +23,7 @@ export var RequestEvent = {
     ERROR: "error",
     UNRECOVERABLE_ERROR: "unrecoverableError",
 };
-export var EventResultType = {
+export const EventResultType = {
     /** @deprecated use 'RESPOND' */
     Respond: "respond",
     /** @deprecated use 'RETRY' */
@@ -31,7 +31,7 @@ export var EventResultType = {
     RESPOND: "respond",
     RETRY: "retry",
 };
-export var CacheSource = {
+export const CacheSource = {
     /** @deprecated use 'API' */
     Api: "api",
     /** @deprecated use 'LOCAL' */
@@ -39,7 +39,7 @@ export var CacheSource = {
     API: "api",
     LOCAL: "local",
 };
-export var ResponseType = {
+export const ResponseType = {
     /** @deprecated use 'JSON' */
     Json: "json",
     /** @deprecated use 'TEXT' */

package/esm/ApiTypes.d.ts

@@ -4,20 +4,33 @@ import { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType
 export declare type AcceptableStatus = number | [min: number, max: number];
 export declare type Headers = Record<string, string | number | boolean | null | undefined>;
 export declare type Params = string;
-export declare type Query = Record<string, any>;
+export declare type Query = string | undefined | Record<string, any>;
 export declare type Body = string | number | Record<string, any>;
 export interface ApiResponse<T = any> {
-    status: number;
-    data: T;
-    headers: Record<string, string>;
+    readonly method: RequestMethod;
+    readonly url: string;
+    readonly status: number;
+    readonly data: T;
+    readonly headers: Record<string, string>;
+}
+export declare type RequestLock = string | false;
+export declare type QueryStringify = (query: any) => string;
+export declare type QueryParse = (query: string) => any;
+interface QueryHandling {
+    parse: QueryParse;
+    stringify: QueryStringify;
 }
 export interface BaseRequestConfig {
     cache?: number | boolean;
-    lock?: string | false;
+    lock?: RequestLock;
     retry?: number | false;
     headers?: Readonly<Headers>;
     acceptableStatus?: AcceptableStatus[];
-    queryParser?: (query: any) => string;
+    /**
+     * @deprecated use `queryHandling.stringify` instead
+     **/
+    queryParser?: QueryStringify;
+    queryHandling?: Partial<QueryHandling>;
 }
 export declare type RequestConfig<P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> = (P extends undefined ? {
     params?: never;
@@ -32,13 +45,20 @@ export declare type RequestConfig<P extends Params | undefined = Params | undefi
 } : {
     body: B;
 }) & BaseRequestConfig;
+export declare const COMPUTED_CONFIG_SYMBOL: unique symbol;
+export declare type ComputedRequestConfig<P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> = Omit<RequestConfig<P, Q, B>, "queryParser" | "query" | "queryHandling"> & {
+    [COMPUTED_CONFIG_SYMBOL]: true;
+    queryObject: Record<string, any> | undefined;
+    queryString: string | undefined;
+    queryHandling: QueryHandling;
+};
 interface BaseEventResult<T extends EventResultType> {
     type: T;
 }
-export declare type ResponseEventResult<R> = BaseEventResult<typeof EventResultType.Respond> & {
+export declare type ResponseEventResult<R> = BaseEventResult<"respond"> & {
     response: ApiResponse<R>;
 };
-export declare type RetryEventResult<R> = BaseEventResult<typeof EventResultType.Retry>;
+export declare type RetryEventResult<R> = BaseEventResult<"retry">;
 export declare type EventResult<R> = ResponseEventResult<R> | RetryEventResult<R>;
 export declare type RequestEventHandler<R> = (context: RequestContext<R>) => EventResult<R> | void | Promise<EventResult<R> | void>;
 export declare type RequestEventHandlers<R> = {
@@ -59,8 +79,8 @@ export interface RequestHost {
     readonly api: Api;
     readonly baseUrl: string;
     readonly path: string;
-    readonly responseType: ResponseType;
-    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): RequestConfig<P, Q, B>;
+    readonly responseType: ResponseType | undefined;
+    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): ComputedRequestConfig<P, Q, B>;
     computePath(path: string, config: RequestConfig): string;
 }
 export interface CancelledRequestError extends Error {

package/esm/ApiTypes.js

@@ -1 +1 @@
-export {};
+export const COMPUTED_CONFIG_SYMBOL = Symbol("computed");

package/esm/ApiUtils.js

@@ -1,19 +1,18 @@
-export var isCancelledError = function (error) {
+export const isCancelledError = (error) => {
     return "isCancelledRequest" in error;
 };
-export var isNetworkError = function (error) {
+export const isNetworkError = (error) => {
     var _a;
     return (error.name === "NetworkError" ||
         error.message === "Network Error" ||
         ((_a = error.constructor) === null || _a === void 0 ? void 0 : _a.name) === "NetworkError");
 };
-var DEFAULT_ACCEPTABLE_STATUS = [[200, 299], 304];
-export var isAcceptableStatus = function (status, acceptableStatus) {
-    var acceptable = acceptableStatus !== null && acceptableStatus !== void 0 ? acceptableStatus : DEFAULT_ACCEPTABLE_STATUS;
-    for (var _i = 0, acceptable_1 = acceptable; _i < acceptable_1.length; _i++) {
-        var cmpStatus = acceptable_1[_i];
+const DEFAULT_ACCEPTABLE_STATUS = [[200, 299], 304];
+export const isAcceptableStatus = (status, acceptableStatus) => {
+    const acceptable = acceptableStatus !== null && acceptableStatus !== void 0 ? acceptableStatus : DEFAULT_ACCEPTABLE_STATUS;
+    for (const cmpStatus of acceptable) {
         if (Array.isArray(cmpStatus)) {
-            var min = cmpStatus[0], max = cmpStatus[1];
+            const [min, max] = cmpStatus;
             if (status >= min && status <= max) {
                 return (true);
             }
@@ -26,11 +25,11 @@ export var isAcceptableStatus = function (status, acceptableStatus) {
     }
     return (false);
 };
-var TEXT_CONTENT_TYPES = ["text/plain"];
-var JSON_CONTENT_TYPES = ["text/json", "application/json"];
-var ARRAY_BUFFER_CONTENT_TYPES = ["application/octet-stream"];
-export var inferResponseType = function (contentType) {
-    var contentTypePart = contentType === null || contentType === void 0 ? void 0 : contentType.split(";")[0].trim();
+const TEXT_CONTENT_TYPES = ["text/plain", "text/html", "text/xml", "application/xml"];
+const JSON_CONTENT_TYPES = ["text/json", "application/json"];
+const ARRAY_BUFFER_CONTENT_TYPES = ["application/octet-stream"];
+export const inferResponseType = (contentType) => {
+    const contentTypePart = contentType === null || contentType === void 0 ? void 0 : contentType.split(";")[0].trim();
     if (contentTypePart) {
         if (TEXT_CONTENT_TYPES.includes(contentTypePart)) {
             return "text";

package/esm/Endpoint.d.ts

@@ -1,5 +1,5 @@
 import { Api } from "./Api";
-import { ApiResponse, BaseRequestConfig, Body, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
+import { ApiResponse, BaseRequestConfig, Body, ComputedRequestConfig, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
 import * as Mocking from "./MockingTypes";
 import { RequestMethod, ResponseType } from "./ApiConstants";
 export interface EndpointConfig<R, P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined> {
@@ -37,11 +37,11 @@ export default class Endpoint<R = any, P extends Params | undefined = Params | u
     readonly description?: string;
     readonly path: string;
     readonly config?: BaseRequestConfig;
-    readonly responseType: ResponseType;
+    readonly responseType: ResponseType | undefined;
     readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
     constructor(api: Api, info: EndpointConfig<R, P, Q, B>);
     submit(config: RequestConfig<P, Q, B>): Promise<ApiResponse<R>>;
     computePath(path: string, request: RequestConfig): string;
     get baseUrl(): string;
-    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): RequestConfig<P, Q, B>;
+    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): ComputedRequestConfig<P, Q, B>;
 }

package/esm/Endpoint.js

@@ -7,38 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
-    }
-};
 import * as Requester from "./Requester";
+import { COMPUTED_CONFIG_SYMBOL, } from "./ApiTypes";
 import * as Utils from "./Utils";
-import { ResponseType } from "./ApiConstants";
-var Endpoint = /** @class */ (function () {
-    function Endpoint(api, info) {
+import { computeRequestConfig } from "./RequestConfig";
+export default class Endpoint {
+    constructor(api, info) {
         this.api = api;
         this.id = info.id;
         this.method = info.method;
@@ -46,60 +20,54 @@ var Endpoint = /** @class */ (function () {
         this.description = info.description;
         this.path = info.path;
         this.config = info.config;
-        this.responseType = info.responseType || ResponseType.Json;
+        this.responseType = info.responseType;
         this.mocking = info.mocking;
     }
-    Endpoint.prototype.submit = function (config) {
+    submit(config) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var mock, apiMocking, mockingEnabled;
-            return __generator(this, function (_c) {
-                mock = false;
-                apiMocking = this.api.mocking;
-                if (apiMocking) {
-                    mockingEnabled = (_a = (typeof apiMocking.enabled === "function" ? apiMocking.enabled() : apiMocking.enabled)) !== null && _a !== void 0 ? _a : false;
-                    if (mockingEnabled) {
-                        if (!((_b = this.mocking) === null || _b === void 0 ? void 0 : _b.handler)) {
-                            throw new Error("[api-def] Endpoint for '".concat(this.path, "' has no mocking"));
-                        }
-                        mock = true;
+        return __awaiter(this, void 0, void 0, function* () {
+            let mock = false;
+            const apiMocking = this.api.mocking;
+            if (apiMocking) {
+                const mockingEnabled = (_a = (typeof apiMocking.enabled === "function" ? apiMocking.enabled() : apiMocking.enabled)) !== null && _a !== void 0 ? _a : false;
+                if (mockingEnabled) {
+                    if (!((_b = this.mocking) === null || _b === void 0 ? void 0 : _b.handler)) {
+                        throw new Error(`[api-def] Endpoint for '${this.path}' has no mocking`);
                     }
+                    mock = true;
                 }
-                return [2 /*return*/, Requester.submit(this, config, mock ? this.mocking : null)];
-            });
+            }
+            return Requester.submit(this, config, mock ? this.mocking : null);
         });
-    };
-    Endpoint.prototype.computePath = function (path, request) {
-        var computedPath = path.startsWith("/") ? path : "/".concat(path);
+    }
+    computePath(path, request) {
+        let computedPath = path.startsWith("/") ? path : `/${path}`;
         if (request.params) {
-            var keys = Object.keys(request.params);
-            for (var i = 0; i < keys.length; i++) {
-                var argName = keys[i];
-                computedPath = computedPath.replace(":".concat(argName), request.params[argName]);
+            const keys = Object.keys(request.params);
+            for (let i = 0; i < keys.length; i++) {
+                const argName = keys[i];
+                computedPath = computedPath.replace(`:${argName}`, request.params[argName]);
             }
         }
         if (computedPath.includes(":")) {
-            throw new Error("[api-def] Not all path params have been resolved: '".concat(computedPath, "'"));
+            throw new Error(`[api-def] Not all path params have been resolved: '${computedPath}'`);
         }
         return computedPath;
-    };
-    Object.defineProperty(Endpoint.prototype, "baseUrl", {
-        get: function () {
-            return this.api.baseUrl;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Endpoint.prototype.computeConfig = function (config) {
-        var apiDefaults = this.api.getConfig();
-        var computedConfig = Utils.assign({}, apiDefaults, this.config, config);
-        // merge other values
-        for (var _i = 0, _a = ["headers"]; _i < _a.length; _i++) {
-            var key = _a[_i];
-            computedConfig[key] = Utils.assign({}, apiDefaults[key], this.config ? this.config[key] : undefined, config[key]);
-        }
+    }
+    get baseUrl() {
+        return this.api.baseUrl;
+    }
+    computeConfig(config) {
+        const apiDefaults = this.api.getConfig();
+        const computedConfig = Utils.assign({
+            [COMPUTED_CONFIG_SYMBOL]: true,
+        }, apiDefaults, this.config, config);
+        return computeRequestConfig([
+            apiDefaults,
+            this.config,
+            config,
+        ]);
+        delete computedConfig.queryParser;
         return computedConfig;
-    };
-    return Endpoint;
-}());
-export default Endpoint;
+    }
+}

package/esm/EndpointBuilder.js

@@ -1,25 +1,23 @@
 import Endpoint from "./Endpoint";
-var EndpointBuilder = /** @class */ (function () {
-    function EndpointBuilder(api) {
+export default class EndpointBuilder {
+    constructor(api) {
         this.api = api;
     }
-    EndpointBuilder.prototype.queryOf = function () {
+    queryOf() {
         return this;
-    };
-    EndpointBuilder.prototype.paramsOf = function () {
+    }
+    paramsOf() {
         return this;
-    };
-    EndpointBuilder.prototype.bodyOf = function () {
+    }
+    bodyOf() {
         return this;
-    };
-    EndpointBuilder.prototype.responseOf = function () {
+    }
+    responseOf() {
         return this;
-    };
-    EndpointBuilder.prototype.build = function (config) {
-        var endpoint = new Endpoint(this.api, config);
+    }
+    build(config) {
+        const endpoint = new Endpoint(this.api, config);
         this.api.endpoints[endpoint.id] = endpoint;
         return endpoint;
-    };
-    return EndpointBuilder;
-}());
-export default EndpointBuilder;
+    }
+}

package/esm/QueryHandling.d.ts

@@ -0,0 +1,3 @@
+import { QueryStringify } from "./ApiTypes";
+export declare const DEFAULT_QUERY_STRINGIFY: QueryStringify;
+export declare const DEFAULT_QUERY_PARSE: (queryString: string) => Record<string, any>;

package/esm/QueryHandling.js

@@ -0,0 +1,19 @@
+export const DEFAULT_QUERY_STRINGIFY = (query) => {
+    var _a, _b;
+    const queryStrings = [];
+    const queryKeys = Object.keys(query);
+    for (let i = 0; i < queryKeys.length; i++) {
+        const key = queryKeys[i];
+        queryStrings.push(`${key}=${(_b = (_a = query[key]) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}`);
+    }
+    return queryStrings.join("&");
+};
+export const DEFAULT_QUERY_PARSE = (queryString) => {
+    const query = {};
+    const queryStrings = queryString.split("&");
+    for (let i = 0; i < queryStrings.length; i++) {
+        const [key, value] = queryStrings[i].split("=");
+        query[key] = !(value === null || value === void 0 ? void 0 : value.length) ? true : value;
+    }
+    return query;
+};

package/esm/RequestConfig.d.ts

@@ -0,0 +1,2 @@
+import { BaseRequestConfig, Body, ComputedRequestConfig, Query, RequestConfig } from "./ApiTypes";
+export declare const computeRequestConfig: <P extends string | undefined, Q extends Query, B extends Body | undefined>(configs: (BaseRequestConfig | RequestConfig<P, Q, B> | undefined)[]) => ComputedRequestConfig<P, Q, B>;

package/esm/RequestConfig.js

@@ -0,0 +1,56 @@
+import { COMPUTED_CONFIG_SYMBOL, } from "./ApiTypes";
+import * as Utils from "./Utils";
+import { DEFAULT_QUERY_PARSE, DEFAULT_QUERY_STRINGIFY } from "./QueryHandling";
+const MERGED_CONFIG_KEYS = ["headers"];
+export const computeRequestConfig = (configs) => {
+    var _a, _b;
+    const computedConfig = Utils.assign({
+        [COMPUTED_CONFIG_SYMBOL]: true,
+    }, ...configs);
+    // merge other values
+    for (const key of MERGED_CONFIG_KEYS) {
+        computedConfig[key] = Utils.assign({}, ...configs.reduce((acc, config) => {
+            if (config === null || config === void 0 ? void 0 : config[key]) {
+                acc.push(config[key]);
+            }
+            return acc;
+        }, []));
+    }
+    computedConfig.queryHandling = {
+        parse: ((_a = computedConfig.queryHandling) === null || _a === void 0 ? void 0 : _a.parse) || DEFAULT_QUERY_PARSE,
+        stringify: ((_b = computedConfig.queryHandling) === null || _b === void 0 ? void 0 : _b.stringify) || computedConfig.queryParser || DEFAULT_QUERY_STRINGIFY,
+    };
+    delete computedConfig.queryParser;
+    const query = computedConfig.query;
+    let queryString;
+    let queryObject;
+    if (query) {
+        Object.defineProperty(computedConfig, "queryString", {
+            get() {
+                if (queryString) {
+                    return queryString;
+                }
+                if (typeof query === "string") {
+                    return queryString = query;
+                }
+                return queryString = computedConfig.queryHandling.stringify(query);
+            },
+        });
+        Object.defineProperty(computedConfig, "queryObject", {
+            get() {
+                if (queryObject) {
+                    return queryObject;
+                }
+                if (typeof query === "string") {
+                    return queryObject = computedConfig.queryHandling.parse(query);
+                }
+                return queryObject = query;
+            },
+            set(value) {
+                queryObject = value;
+                queryString = computedConfig.queryHandling.stringify(value);
+            },
+        });
+    }
+    return computedConfig;
+};

package/esm/RequestContext.d.ts

@@ -1,4 +1,4 @@
-import { ApiResponse, Body, EventResult, Headers, Params, Query, RequestCacheInfo, RequestConfig, RequestContextStats, RequestEventHandlers, RequestHost } from "./ApiTypes";
+import { ApiResponse, Body, ComputedRequestConfig, EventResult, Headers, Params, Query, RequestCacheInfo, RequestContextStats, RequestEventHandlers, RequestHost } from "./ApiTypes";
 import { Api } from "./Api";
 import { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
 import { EndpointMockingConfig } from "./MockingTypes";
@@ -17,14 +17,14 @@ export default class RequestContext<R = any, P extends Params | undefined = Para
     error: RequestError | null;
     readonly cacheInfo: RequestCacheInfo;
     cancelled: boolean;
-    readonly computedConfig: RequestConfig<P, Q, B>;
+    readonly computedConfig: ComputedRequestConfig<P, Q, B>;
     readonly mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined;
     private parsedBody;
-    constructor(backend: RequestBackend, host: RequestHost, config: RequestConfig<P, Q, B>, computedPath: string, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined);
+    constructor(backend: RequestBackend, host: RequestHost, config: ComputedRequestConfig<P, Q, B>, computedPath: string, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined);
     get method(): RequestMethod;
     get api(): Api;
     get baseUrl(): string;
-    get responseType(): ResponseType;
+    get responseType(): ResponseType | undefined;
     private initMiddleware;
     private generateKey;
     updateHeaders(newHeaders: Headers): this;