api-def 0.9.1 → 0.9.3

package/esm/ApiConstants.js

@@ -1,52 +1,52 @@
-export const RequestMethod = {
-    /** @deprecated use 'POST' */
-    Post: "post",
-    /** @deprecated use 'GET' */
-    Get: "get",
-    POST: "post",
-    GET: "get",
-    PUT: "put",
-    DELETE: "delete",
-    PATCH: "patch",
-};
-export const RequestEvent = {
-    /** @deprecated use 'BEFORE_SEND' */
-    BeforeSend: "beforeSend",
-    /** @deprecated use 'SUCCESS' */
-    Success: "success",
-    /** @deprecated use 'ERROR' */
-    Error: "error",
-    /** @deprecated use 'UNRECOVERABLE_ERROR' */
-    UnrecoverableError: "unrecoverableError",
-    BEFORE_SEND: "beforeSend",
-    SUCCESS: "success",
-    ERROR: "error",
-    UNRECOVERABLE_ERROR: "unrecoverableError",
-};
-export const EventResultType = {
-    /** @deprecated use 'RESPOND' */
-    Respond: "respond",
-    /** @deprecated use 'RETRY' */
-    Retry: "retry",
-    RESPOND: "respond",
-    RETRY: "retry",
-};
-export const CacheSource = {
-    /** @deprecated use 'API' */
-    Api: "api",
-    /** @deprecated use 'LOCAL' */
-    Local: "local",
-    API: "api",
-    LOCAL: "local",
-};
-export const ResponseType = {
-    /** @deprecated use 'JSON' */
-    Json: "json",
-    /** @deprecated use 'TEXT' */
-    Text: "text",
-    /** @deprecated use 'ARRAY_BUFFER' */
-    ArrayBuffer: "arraybuffer",
-    JSON: "json",
-    TEXT: "text",
-    ARRAY_BUFFER: "arraybuffer",
-};
+export const RequestMethod = {
+    /** @deprecated use 'POST' */
+    Post: "post",
+    /** @deprecated use 'GET' */
+    Get: "get",
+    POST: "post",
+    GET: "get",
+    PUT: "put",
+    DELETE: "delete",
+    PATCH: "patch",
+};
+export const RequestEvent = {
+    /** @deprecated use 'BEFORE_SEND' */
+    BeforeSend: "beforeSend",
+    /** @deprecated use 'SUCCESS' */
+    Success: "success",
+    /** @deprecated use 'ERROR' */
+    Error: "error",
+    /** @deprecated use 'UNRECOVERABLE_ERROR' */
+    UnrecoverableError: "unrecoverableError",
+    BEFORE_SEND: "beforeSend",
+    SUCCESS: "success",
+    ERROR: "error",
+    UNRECOVERABLE_ERROR: "unrecoverableError",
+};
+export const EventResultType = {
+    /** @deprecated use 'RESPOND' */
+    Respond: "respond",
+    /** @deprecated use 'RETRY' */
+    Retry: "retry",
+    RESPOND: "respond",
+    RETRY: "retry",
+};
+export const CacheSource = {
+    /** @deprecated use 'API' */
+    Api: "api",
+    /** @deprecated use 'LOCAL' */
+    Local: "local",
+    API: "api",
+    LOCAL: "local",
+};
+export const ResponseType = {
+    /** @deprecated use 'JSON' */
+    Json: "json",
+    /** @deprecated use 'TEXT' */
+    Text: "text",
+    /** @deprecated use 'ARRAY_BUFFER' */
+    ArrayBuffer: "arraybuffer",
+    JSON: "json",
+    TEXT: "text",
+    ARRAY_BUFFER: "arraybuffer",
+};

package/esm/ApiTypes.d.ts

@@ -1,103 +1,103 @@
-import RequestContext from "./RequestContext";
-import { Api } from "./Api";
-import { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
-import RequestBackend from "./backend/RequestBackend";
-import { Validation } from "./Validation";
-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 = string | undefined | Record<string, any>;
-export declare type Body = string | number | Record<string, any>;
-export interface ApiResponse<T = any> {
-    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 RetryOptions {
-    maxAttempts: number;
-    shouldRetry?: (error: Error) => boolean;
-    minDelay?: number;
-    maxDelay?: number;
-}
-export interface BaseRequestConfig {
-    cache?: number | boolean;
-    lock?: RequestLock;
-    retry?: number | false | RetryOptions;
-    headers?: Readonly<Headers>;
-    acceptableStatus?: AcceptableStatus[];
-    /**
-     * @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;
-} : {
-    params: Record<P extends Params ? P : never, string>;
-}) & (Q extends undefined ? {
-    query?: never;
-} : {
-    query: Q;
-}) & (B extends undefined ? {
-    body?: never;
-} : {
-    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<"respond"> & {
-    response: ApiResponse<R>;
-};
-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> = {
-    [key in RequestEvent]?: Array<RequestEventHandler<R>>;
-};
-export declare type RequestMiddleware<O = undefined> = {
-    [key in RequestEvent]?: RequestEventHandler<any> | undefined | false;
-};
-export interface RequestContextStats {
-    cached: false | {
-        is: true;
-        by: "local" | "api";
-    };
-    attempt: number;
-}
-export interface RequestHost {
-    readonly method: RequestMethod;
-    readonly api: Api;
-    readonly baseUrl: string;
-    readonly path: string;
-    readonly responseType: ResponseType | undefined;
-    readonly validation: Validation;
-    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;
-    getRequestBackend(): RequestBackend;
-}
-export interface CancelledRequestError extends Error {
-    isCancelledRequest: true;
-}
-export interface RequestCacheInfo {
-    cached: boolean;
-    source: CacheSource | null;
-}
-export {};
+import { Api } from "./Api";
+import { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
+import RequestContext from "./RequestContext";
+import { Validation } from "./Validation";
+import RequestBackend from "./backend/RequestBackend";
+export type AcceptableStatus = number | [min: number, max: number];
+export type Headers = Record<string, string | number | boolean | null | undefined>;
+export type Params = string;
+export type Query = string | undefined | Record<string, any>;
+export type Body = string | number | Record<string, any>;
+export interface ApiResponse<T = any> {
+    readonly method: RequestMethod;
+    readonly url: string;
+    readonly status: number;
+    readonly data: T;
+    readonly headers: Record<string, string>;
+}
+export type RequestLock = string | false;
+export type QueryStringify = (query: any) => string;
+export type QueryParse = (query: string) => any;
+interface QueryHandling {
+    parse: QueryParse;
+    stringify: QueryStringify;
+}
+export interface RetryOptions {
+    maxAttempts: number;
+    shouldRetry?: (error: Error) => boolean;
+    minDelay?: number;
+    maxDelay?: number;
+}
+export interface BaseRequestConfig {
+    cache?: number | boolean;
+    lock?: RequestLock;
+    retry?: number | false | RetryOptions;
+    headers?: Readonly<Headers>;
+    acceptableStatus?: AcceptableStatus[];
+    /**
+     * @deprecated use `queryHandling.stringify` instead
+     **/
+    queryParser?: QueryStringify;
+    queryHandling?: Partial<QueryHandling>;
+}
+export 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;
+} : {
+    params: Record<P extends Params ? P : never, string>;
+}) & (Q extends undefined ? {
+    query?: never;
+} : {
+    query: Q;
+}) & (B extends undefined ? {
+    body?: never;
+} : {
+    body: B;
+}) & BaseRequestConfig;
+export declare const COMPUTED_CONFIG_SYMBOL: unique symbol;
+export 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 type ResponseEventResult<R> = BaseEventResult<"respond"> & {
+    response: ApiResponse<R>;
+};
+export type RetryEventResult<R> = BaseEventResult<"retry">;
+export type EventResult<R> = ResponseEventResult<R> | RetryEventResult<R>;
+export type RequestEventHandler<R> = (context: RequestContext<R>) => EventResult<R> | void | Promise<EventResult<R> | void>;
+export type RequestEventHandlers<R> = {
+    [key in RequestEvent]?: Array<RequestEventHandler<R>>;
+};
+export type RequestMiddleware<O = undefined> = {
+    [key in RequestEvent]?: RequestEventHandler<any> | undefined | false;
+};
+export interface RequestContextStats {
+    cached: false | {
+        is: true;
+        by: "local" | "api";
+    };
+    attempt: number;
+}
+export interface RequestHost {
+    readonly method: RequestMethod;
+    readonly api: Api;
+    readonly baseUrl: string;
+    readonly path: string;
+    readonly responseType: ResponseType | undefined;
+    readonly validation: Validation;
+    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;
+    getRequestBackend(): RequestBackend;
+}
+export interface CancelledRequestError extends Error {
+    isCancelledRequest: true;
+}
+export interface RequestCacheInfo {
+    cached: boolean;
+    source: CacheSource | null;
+}
+export {};

package/esm/ApiTypes.js

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

package/esm/ApiUtils.d.ts

@@ -1,6 +1,6 @@
-import { AcceptableStatus, CancelledRequestError } from "./ApiTypes";
-import { ResponseType } from "./ApiConstants";
-export declare const isCancelledError: (error: Error) => error is CancelledRequestError;
-export declare const isNetworkError: (error: Error) => boolean;
-export declare const isAcceptableStatus: (status: number, acceptableStatus?: AcceptableStatus[]) => boolean;
-export declare const inferResponseType: (contentType: string | null | undefined) => ResponseType;
+import { ResponseType } from "./ApiConstants";
+import { AcceptableStatus, CancelledRequestError } from "./ApiTypes";
+export declare const isCancelledError: (error: Error) => error is CancelledRequestError;
+export declare const isNetworkError: (error: Error) => boolean;
+export declare const isAcceptableStatus: (status: number, acceptableStatus?: AcceptableStatus[]) => boolean;
+export declare const inferResponseType: (contentType: string | null | undefined) => ResponseType;

package/esm/ApiUtils.js

@@ -1,45 +1,43 @@
-export const isCancelledError = (error) => {
-    return "isCancelledRequest" in 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");
-};
-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)) {
-            const [min, max] = cmpStatus;
-            if (status >= min && status <= max) {
-                return (true);
-            }
-        }
-        else if (!isNaN(cmpStatus)) {
-            if (status === cmpStatus) {
-                return (true);
-            }
-        }
-    }
-    return (false);
-};
-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";
-        }
-        else if (JSON_CONTENT_TYPES.includes(contentTypePart)) {
-            return "json";
-        }
-        else if (ARRAY_BUFFER_CONTENT_TYPES.includes(contentTypePart)) {
-            return "arraybuffer";
-        }
-    }
-    return "text";
-};
+export const isCancelledError = (error) => {
+    return "isCancelledRequest" in 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";
+};
+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)) {
+            const [min, max] = cmpStatus;
+            if (status >= min && status <= max) {
+                return true;
+            }
+        }
+        else if (!Number.isNaN(cmpStatus)) {
+            if (status === cmpStatus) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+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";
+        }
+        if (JSON_CONTENT_TYPES.includes(contentTypePart)) {
+            return "json";
+        }
+        if (ARRAY_BUFFER_CONTENT_TYPES.includes(contentTypePart)) {
+            return "arraybuffer";
+        }
+    }
+    return "text";
+};

package/esm/Endpoint.d.ts

@@ -1,52 +1,52 @@
-import { Api } from "./Api";
-import { ApiResponse, BaseRequestConfig, Body, ComputedRequestConfig, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
-import * as Mocking from "./MockingTypes";
-import { RequestMethod, ResponseType } from "./ApiConstants";
-import RequestBackend from "./backend/RequestBackend";
-import { Validation } from "./Validation";
-export interface EndpointConfig<R, P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined, Path extends string = string> {
-    readonly id: string;
-    readonly method: RequestMethod;
-    readonly path: Path;
-    /**
-     * Name your endpoint to help with debugging and documentation
-     * @default `id` is used as the name if no name is supplied
-     */
-    readonly name?: string;
-    /**
-     * Describe your endpoint to help with debugging and documentation
-     */
-    readonly description?: string;
-    readonly config?: BaseRequestConfig;
-    /**
-     * Let the backend requestor (fetch, axios, etc.) know what type of response
-     * you are expecting from this endpoint
-     * @default `application/json`
-     */
-    readonly responseType?: ResponseType;
-    /**
-     * Specify mocking for your endpoint upfront to help with disconnected dev,
-     * and testing.
-     * Enable/disable mocked returns for all endpoints on your API object.
-     */
-    readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
-    readonly validation?: Validation<R, P, Q, B>;
-}
-export default class Endpoint<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> implements EndpointConfig<R, P, Q, B>, RequestHost {
-    readonly api: Api;
-    readonly id: string;
-    readonly method: RequestMethod;
-    readonly name: string;
-    readonly description?: string;
-    readonly path: string;
-    readonly config?: BaseRequestConfig;
-    readonly responseType: ResponseType | undefined;
-    readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
-    readonly validation: Validation<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>): ComputedRequestConfig<P, Q, B>;
-    getRequestBackend(): RequestBackend;
-}
+import { Api } from "./Api";
+import { RequestMethod, ResponseType } from "./ApiConstants";
+import { ApiResponse, BaseRequestConfig, Body, ComputedRequestConfig, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
+import * as Mocking from "./MockingTypes";
+import { Validation } from "./Validation";
+import RequestBackend from "./backend/RequestBackend";
+export interface EndpointConfig<R, P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined, Path extends string = string> {
+    readonly id: string;
+    readonly method: RequestMethod;
+    readonly path: Path;
+    /**
+     * Name your endpoint to help with debugging and documentation
+     * @default `id` is used as the name if no name is supplied
+     */
+    readonly name?: string;
+    /**
+     * Describe your endpoint to help with debugging and documentation
+     */
+    readonly description?: string;
+    readonly config?: BaseRequestConfig;
+    /**
+     * Let the backend requestor (fetch, axios, etc.) know what type of response
+     * you are expecting from this endpoint
+     * @default `application/json`
+     */
+    readonly responseType?: ResponseType;
+    /**
+     * Specify mocking for your endpoint upfront to help with disconnected dev,
+     * and testing.
+     * Enable/disable mocked returns for all endpoints on your API object.
+     */
+    readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
+    readonly validation?: Validation<R, P, Q, B>;
+}
+export default class Endpoint<R = any, P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> implements EndpointConfig<R, P, Q, B>, RequestHost {
+    readonly api: Api;
+    readonly id: string;
+    readonly method: RequestMethod;
+    readonly name: string;
+    readonly description?: string;
+    readonly path: string;
+    readonly config?: BaseRequestConfig;
+    readonly responseType: ResponseType | undefined;
+    readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
+    readonly validation: Validation<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>): ComputedRequestConfig<P, Q, B>;
+    getRequestBackend(): RequestBackend;
+}