@ethlete/query 0.1.0-next.21 → 0.1.0-next.22

package/lib/directives/query.directive.d.ts

@@ -1,12 +1,13 @@
 import { ChangeDetectorRef, ErrorHandler, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
 import { AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, QueryOf, QueryRawResponseType, QueryResponseType } from '../query';
-import { RequestError } from '../request';
+import { RequestError, RequestProgress } from '../request';
 import * as i0 from "@angular/core";
 interface QueryContext<Q extends AnyQuery | null> {
     $implicit: QueryResponseType<Q>;
     query: QueryResponseType<Q>;
     raw: QueryRawResponseType<Q>;
     loading: boolean;
+    progress: RequestProgress | null;
     error: RequestError<unknown> | null;
 }
 export declare class QueryDirective<Q extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null> implements OnInit, OnDestroy {

package/lib/query/query.d.ts

@@ -4,10 +4,9 @@ import { BaseArguments, GqlQueryConfig, PollConfig, QueryState, RestQueryConfig,
 export declare class Query<Response, Arguments extends (BaseArguments & WithUseResultIn<Response, ResponseTransformer>) | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
     private _client;
     private _queryConfig;
-    private _route;
+    private _routeWithParams;
     private _args;
     private _currentId;
-    private _abortController;
     private _pollingSubscription;
     private _onAbort$;
     private readonly _state$;
@@ -15,12 +14,11 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
     get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
     get state(): QueryState<ReturnType<ResponseTransformer>, Response>;
     get isExpired(): boolean;
-    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _route: Route, _args: Arguments | undefined);
+    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _routeWithParams: Route, _args: Arguments | undefined);
     clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;
     execute<ComputedResponse extends ReturnType<ResponseTransformer>>(options?: RunQueryOptions): this;
     abort(): this;
     poll(config: PollConfig): this;
     stopPolling(): this;
     private _updateUseResultInDependencies;
-    private _handleExecuteError;
 }

package/lib/query/query.types.d.ts

@@ -1,16 +1,12 @@
 import { Observable } from 'rxjs';
 import { AnyQueryCreator, QueryCreatorReturnType, ResponseTransformerType } from '../query-client';
-import { Method, PathParams, QueryParams, RequestError } from '../request';
+import { Method, PathParams, QueryParams, RequestError, RequestProgress } from '../request';
 import { Query } from './query';
-export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
+export interface QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
     /**
      * The http method to use for the query.
      */
     method: Method;
-    /**
-     * The api route to use for the query.
-     */
-    route: Route;
     /**
      * Determines if the auth provider should be used for this query.
      * The query **will throw** if the query client's auth provider is unset.
@@ -21,6 +17,20 @@ export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, A
      * A function that transforms the response to the desired type.
      */
     responseTransformer?: ResponseTransformer;
+    /**
+     * Determines if the query should emit progress events.
+     */
+    reportProgress?: boolean;
+    /**
+     * Determines the query's response type.
+     * @default 'json'
+     */
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    /**
+     * Whether this request should be sent with outgoing credentials (cookies).
+     * @default false
+     */
+    withCredentials?: boolean;
     /**
      * Object containing the query's type information.
      */
@@ -36,20 +46,26 @@ export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, A
          * - `queryParams`: The query parameters for the query. (after the ? in the url)
          * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
          * - `headers`: The headers for the query.
+         * - `variables`: The variables for the query. (graphql only)
          */
         args?: Arguments;
     };
 }
-export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
-    method: Method;
+export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> extends QueryConfigBase<Response, Arguments, ResponseTransformer> {
+    /**
+     * The api route to use for the query.
+     */
+    route: Route;
+}
+export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> extends QueryConfigBase<Response, Arguments, ResponseTransformer> {
+    /**
+     * The graphql query to use for the query.
+     */
     query: string;
+    /**
+     * Subroute to use for the query.
+     */
     route?: Route;
-    secure?: boolean;
-    responseTransformer?: ResponseTransformer;
-    types?: {
-        response?: Response;
-        args?: Arguments;
-    };
 }
 export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<RestQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
 export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
@@ -92,33 +108,35 @@ export declare const enum QueryStateType {
     Cancelled = "CANCELLED"
 }
 export interface Prepared {
-    readonly type: QueryStateType.Prepared;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Prepared;
+    meta: QueryStateMeta;
 }
 export interface Success<Response = unknown, RawResponse = unknown> {
-    readonly type: QueryStateType.Success;
-    readonly response: Response;
-    readonly rawResponse: RawResponse;
-    readonly meta: QueryStateSuccessMeta;
+    type: QueryStateType.Success;
+    response: Response;
+    rawResponse: RawResponse;
+    meta: QueryStateSuccessMeta;
 }
 export interface Failure {
-    readonly type: QueryStateType.Failure;
-    readonly error: RequestError;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Failure;
+    error: RequestError;
+    meta: QueryStateMeta;
 }
 export interface Loading {
-    readonly type: QueryStateType.Loading;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Loading;
+    meta: QueryStateMeta;
+    partialText?: string;
+    progress?: RequestProgress;
 }
 export interface Cancelled {
-    readonly type: QueryStateType.Cancelled;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Cancelled;
+    meta: QueryStateMeta;
 }
 export interface QueryStateMeta {
-    readonly id: number;
+    id: number;
 }
 export interface QueryStateSuccessMeta extends QueryStateMeta {
-    readonly expiresAt: number | null;
+    expiresAt?: number;
 }
 export type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
 export type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;

package/lib/request/request.d.ts

@@ -1,9 +1,3 @@
-import { CacheAdapterFn } from './request.types';
-export declare const request: <Response_1 = unknown>(options: {
-    route: string;
-    init?: RequestInit;
-    cacheAdapter?: CacheAdapterFn;
-}) => Promise<{
-    data: Response_1;
-    expiresInTimestamp: number | null;
-}>;
+import { Observable } from 'rxjs';
+import { RequestConfig, RequestEvent } from './request.types';
+export declare const request: <Response_1 = unknown>(config: RequestConfig) => Observable<RequestEvent<Response_1>>;

package/lib/request/request.types.d.ts

@@ -1,11 +1,9 @@
 export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
 export interface RequestError<Detail = unknown> {
-    code: number;
-    message: string;
-    detail: Detail;
-    raw: unknown;
-    route: string;
-    requestInit?: RequestInit;
+    url: string;
+    status: Detail;
+    statusText: string;
+    detail: unknown;
 }
 export type ParamPrimitive = string | number | boolean | null | undefined;
 export type Params = Record<string | number | symbol, ParamPrimitive | ParamArray>;
@@ -14,5 +12,51 @@ export type UnfilteredParamPrimitive = string | number | boolean | null | undefi
 export type QueryParams = Record<string | number | symbol, UnfilteredParamPrimitive | UnfilteredParamArray>;
 export type PathParams = Record<string, string | number>;
 export type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
-export type CacheAdapterFn = (headers: Headers) => number | null;
+export type CacheAdapterFn = (headers: RequestHeaders) => number | null;
 export type RequestHeaders = Record<string, string>;
+export interface PartialXhrState {
+    headers: RequestHeaders;
+    status: number;
+    statusText: string;
+    url: string;
+}
+export interface RequestConfig {
+    method: Method;
+    urlWithParams: string;
+    body?: unknown;
+    reportProgress?: boolean;
+    withCredentials?: boolean;
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    headers?: RequestHeaders;
+    cacheAdapter?: CacheAdapterFn;
+}
+export type RequestProgress = {
+    current: number;
+    percentage?: number;
+    total?: number;
+};
+export type RequestEvent<Response = unknown> = {
+    type: 'start';
+    headers: RequestHeaders;
+} | {
+    type: 'download-progress';
+    headers: RequestHeaders;
+    progress: RequestProgress;
+    partialText?: string;
+} | {
+    type: 'upload-progress';
+    headers: RequestHeaders;
+    progress: RequestProgress;
+} | {
+    type: 'success';
+    headers: RequestHeaders;
+    response: Response;
+    expiresInTimestamp?: number;
+} | {
+    type: 'failure';
+    headers: RequestHeaders;
+    error: RequestError;
+} | {
+    type: 'cancel';
+    headers: RequestHeaders;
+};

package/lib/request/request.util.d.ts

@@ -1,6 +1,5 @@
-import { Method, ParamArray, Params, QueryParams, RequestError, UnfilteredParamPrimitive } from './request.types';
-export declare const isRequestError: (error: unknown) => error is RequestError<unknown>;
-export declare const isAbortRequestError: (error: unknown) => error is RequestError<unknown>;
+import { Method, ParamArray, Params, QueryParams, RequestError, RequestHeaders, UnfilteredParamPrimitive } from './request.types';
+export declare const isRequestError: <T = unknown>(error: unknown) => error is RequestError<T>;
 export declare const buildRoute: (options: {
     base: string;
     route: string | ((args: Record<string, unknown>) => string) | null | undefined;
@@ -12,9 +11,77 @@ export declare const buildQueryArrayString: (key: string, array: ParamArray) =>
 export declare const isFetchResponse: (response: unknown) => response is Response;
 export declare const filterInvalidParams: (params: QueryParams) => Params;
 export declare const isParamValid: (primitive: UnfilteredParamPrimitive) => boolean;
-export declare const extractExpiresInSeconds: (headers: Headers) => number | null;
+export declare const extractExpiresInSeconds: (headers: RequestHeaders) => number | null;
 export declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
-export declare const buildRequestError: <ErrorResponse = unknown>(error: unknown, route: string, requestInit?: RequestInit) => Promise<RequestError<null> | RequestError<ErrorResponse>>;
-export declare const buildBody: (body: unknown) => string | FormData | null;
+export declare const serializeBody: (body: unknown) => ArrayBuffer | Blob | FormData | string | null;
 export declare const transformMethod: (method: Method) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
-export declare const guessContentType: (body: unknown) => "text/plain" | "multipart/form-data" | "application/json" | null;
+export declare const detectContentTypeHeader: (body: unknown) => string | null;
+export declare const hasHeader: (headers: RequestHeaders, header: string) => boolean;
+export declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;
+export declare const parseAllXhrResponseHeaders: (xhr: XMLHttpRequest) => RequestHeaders;
+export declare const getResponseUrl: (xhr: XMLHttpRequest) => string | null;
+export declare const enum HttpStatusCode {
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    EarlyHints = 103,
+    Ok = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    ImUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    Unused = 306,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    UriTooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "0.1.0-next.21",
+  "version": "0.1.0-next.22",
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
     "@angular/common": "^14.2.0 || ^15.0.0",
     "@angular/core": "^14.2.0 || ^15.0.0",
-    "@ethlete/core": "0.2.0-next.18",
+    "@ethlete/core": "0.2.0-next.19",
     "@angular/forms": "15.1.4",
     "@angular/router": "15.1.4"
   },