ng2-rest 19.0.59 → 21.0.4

package/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng2-rest/browser",
-  "version": "19.0.59",
+  "version": "21.0.4",
   "module": "fesm2022/ng2-rest.mjs",
   "typings": "index.d.ts",
   "exports": {

package/browser/types/ng2-rest.d.ts

@@ -0,0 +1,429 @@
+// @ts-nocheck
+import { Circ, JSON10 } from 'json10/browser';
+import { Observable, Subject } from 'rxjs';
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { CoreModels, CoreHelpers } from 'tnp-core/browser';
+import { Models as Models$1 } from 'typescript-class-helpers/browser';
+import express from 'express';
+
+declare class Cookie {
+    static get Instance(): Cookie;
+    private static __instance;
+    private constructor();
+    read(name: string): string;
+    write(name: string, value: string, days?: number): void;
+    remove(name: string): void;
+}
+
+declare namespace Mapping {
+    function decode(json: Object, autodetect?: boolean): Mapping;
+    function encode<T = Function>(json: Object, mapping: Mapping, circular?: Circ[]): T;
+    function getModelsMapping(entity: Function): {};
+    type Mapping<T = {}> = {
+        [P in keyof T]?: string | string[];
+    };
+    type ModelValue<T> = {
+        [propName in keyof T]?: T[propName];
+    };
+    function DefaultModelWithMapping<T = Object>(defaultModelValues?: ModelValue<T>, mapping?: Mapping<T>): (target: Function) => void;
+}
+
+/**
+ * Based on Headers from https://github.com/angular/angular/blob/master/packages/http/src/headers.ts
+ */
+type RestHeadersOptions = RestHeaders | {
+    [name: string]: (string | string[]);
+};
+declare class RestHeaders {
+    /** @internal header names are lower case */
+    _headers: Map<string, string[]>;
+    /** @internal map lower case names to actual names */
+    _normalizedNames: Map<string, string>;
+    static from(headers?: RestHeadersOptions): RestHeaders;
+    private constructor();
+    /**
+     * Returns a new RestHeaders instance from the given DOMString of Response RestHeaders
+     */
+    static fromResponseHeaderString(headersString: string): RestHeaders;
+    /**
+     * Appends a header to existing list of header values for a given header name.
+     */
+    append(name: string, value: string): void;
+    /**
+     * Deletes all header values for the given name.
+     */
+    delete(name: string): void;
+    forEach(fn: (values: string[], name: string, headers: Map<string, string[]>) => void): void;
+    /**
+     * Returns first header that matches given name.
+     */
+    get(name: string): string;
+    /**
+     * Checks for existence of header by given name.
+     */
+    has(name: string): boolean;
+    /**
+     * Returns the names of the headers
+     */
+    keys(): string[];
+    /**
+     * Sets or overrides header value for given name.
+     */
+    set(name: string, value: string | string[]): void;
+    /**
+     * Returns values of all headers.
+     */
+    values(): string[][];
+    /**
+     * Returns string of all headers.
+     */
+    toJSON(): {
+        [name: string]: any;
+    };
+    /**
+     * Returns list of header values for a given name.
+     */
+    getAll(name: string): string[];
+    private mayBeSetNormalizedName;
+}
+
+interface AxiosTaonHttpHandler<T = any> {
+    handle(req: AxiosRequestConfig): Observable<AxiosResponse<T>>;
+}
+interface TaonClientMiddlewareInterceptOptions<T = any> {
+    req: AxiosRequestConfig;
+    next: AxiosTaonHttpHandler<T>;
+}
+interface TaonServerMiddlewareInterceptOptions<T = any> {
+    req: express.Request;
+    res: express.Response;
+    next: express.NextFunction;
+}
+interface TaonAxiosClientInterceptor<T = any> {
+    intercept(client: TaonClientMiddlewareInterceptOptions<T>): Observable<AxiosResponse<T>>;
+}
+declare class AxiosBackendHandler<T = any> implements AxiosTaonHttpHandler<T> {
+    handle(req: AxiosRequestConfig): Observable<AxiosResponse<T>>;
+}
+declare const buildInterceptorChain: <T = any>(interceptors: Array<TaonAxiosClientInterceptor<T>>, backend: AxiosTaonHttpHandler<T>) => AxiosTaonHttpHandler<T>;
+
+declare class RestRequest {
+    static zone: any;
+    private static jobId;
+    private subjectInuUse;
+    private meta;
+    /**
+     * key is interceptorName (just to identify who is intercepting)
+     */
+    interceptors: Map<string, TaonAxiosClientInterceptor<any>>;
+    /**
+     * key is a joined string METHOD-expressPath.
+     * Example `GET-/api/users`
+     */
+    methodsInterceptors: Map<string, TaonAxiosClientInterceptor<any>>;
+    private handlerResult;
+    private req;
+    private getReplay;
+    private generalReq;
+    get(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    head(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    delete(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    post(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    put(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    patch(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    jsonp(url: string, body: string, headers: RestHeaders, meta: Models.MetaRequest, isArray: boolean, mockHttp: Models.MockHttp, axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<any>;
+    private replaySubjects;
+}
+
+declare class Rest<T, TA = T[]> implements Models.FnMethodsHttpWithMock<T, TA> {
+    private request;
+    private meta;
+    private customContentType;
+    private mockHttp;
+    mock(mock: Models.MockHttp): Models.FnMethodsHttp<T, TA>;
+    private __meta_endpoint;
+    private _endpointRest;
+    private get endpoint();
+    private restQueryParams;
+    set __rest_endpoint(endpoint: any);
+    private creatUrl;
+    private _headers;
+    get headers(): RestHeaders;
+    constructor(endpoint: string, request: RestRequest, meta: Models.MetaRequest, customContentType: RestHeaders);
+    private req;
+    array: {
+        get: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        head: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        post: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        put: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        patch: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        delete: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+        jsonp: (item: TA, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig) => Models.PromiseObservableMix<Models.HttpResponse<TA>>;
+    };
+    get(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    head(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    post(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    put(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    patch(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    delete(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+    jsonp(item: T, params?: Models.UrlParams[], axiosOptions?: Models.Ng2RestAxiosRequestConfig): Models.PromiseObservableMix<Models.HttpResponse<T>>;
+}
+
+declare class RestCommonHttpResponseWrapper {
+    success?: boolean;
+}
+declare class RestResponseWrapper extends RestCommonHttpResponseWrapper {
+    data?: any;
+}
+declare class RestErrorResponseWrapper extends RestCommonHttpResponseWrapper {
+    message: string;
+    /**
+     * stack trace / more details about error
+     */
+    details?: string;
+    /**
+     * http status code
+     */
+    status?: number;
+    /**
+     * custom error code from backend
+     */
+    code?: string;
+}
+declare namespace Models {
+    export import HttpMethod = CoreModels.HttpMethod;
+    export import ParamType = CoreModels.ParamType;
+    export import MethodConfig = Models$1.MethodConfig;
+    export import ClassConfig = Models$1.ClassConfig;
+    export import ParamConfig = Models$1.ParamConfig;
+    interface HandleResultOptions {
+        res: Models.MockResponse;
+        method: Models.HttpMethod;
+        jobid?: number;
+        isArray?: boolean;
+    }
+    interface HandleResultSourceRequestOptions {
+        url: string;
+        method: Models.HttpMethod;
+        body: any;
+        isArray: boolean;
+    }
+    type BackendError = {
+        msg?: string;
+        stack?: string[];
+        data: any;
+    };
+    type MetaRequest = {
+        path: string;
+        endpoint: string;
+        entity: Mapping.Mapping;
+        circular: Circ[];
+    };
+    type HttpCode = 200 | 400 | 401 | 404 | 500;
+    type PromiseObservableMix<T> = Promise<T> & {
+        observable: Observable<T>;
+    };
+    type Ng2RestAxiosRequestConfig = {
+        doNotSerializeParams?: boolean;
+    } & AxiosRequestConfig<any>;
+    type MethodWithBody<E, T, R = PromiseObservableMix<E>> = (item?: T, params?: UrlParams[], axiosOptions?: Ng2RestAxiosRequestConfig) => R;
+    type ReplayData = {
+        subject: Subject<any>;
+        data: {
+            url: string;
+            body: string;
+            headers: RestHeaders;
+            isArray: boolean;
+        };
+        /**
+         * jobid
+         */
+        id: number;
+    };
+    type ReqParams = {
+        url: string;
+        method: CoreModels.HttpMethod;
+        headers?: RestHeaders;
+        body?: any;
+        jobid: number;
+        isArray: boolean;
+    };
+    interface ResourceModel<A, TA> {
+        model: (pathModels?: Object, responseObjectType?: Function) => Rest<A, TA>;
+        headers: RestHeaders;
+    }
+    interface Ng2RestMethods<E, T> {
+        get: MethodWithBody<E, T>;
+        post: MethodWithBody<E, T>;
+        put: MethodWithBody<E, T>;
+        patch: MethodWithBody<E, T>;
+        head: MethodWithBody<E, T>;
+        delete: MethodWithBody<E, T>;
+        jsonp: MethodWithBody<E, T>;
+    }
+    type MockController = (url: string, method: CoreModels.HttpMethod, headers?: RestHeaders, body?: any) => MockResponse;
+    type MockHttp = MockResponse | MockController;
+    interface FnMethodsHttp<T, TA> extends Ng2RestMethods<HttpResponse<T>, T> {
+        array: Ng2RestMethods<HttpResponse<TA>, TA>;
+    }
+    interface FnMethodsHttpWithMock<T, TA> extends Ng2RestMethods<HttpResponse<T>, T> {
+        array: Ng2RestMethods<HttpResponse<TA>, TA>;
+    }
+    interface NestedParams {
+        [params: string]: string;
+    }
+    interface UrlParams {
+        [urlModelName: string]: string | number | boolean | RegExp | Object;
+        regex?: RegExp;
+    }
+    abstract class BaseBody {
+        protected toJSON(data: any, opt: {
+            isJSONArray?: boolean;
+            parsingError?: boolean;
+        }): object | undefined;
+    }
+    class HttpBody<T> extends BaseBody {
+        private responseText;
+        private isArray;
+        private entity;
+        private circular;
+        constructor(responseText: string | Blob, isArray: boolean, entity: Mapping.Mapping, circular: Circ[]);
+        get blob(): Blob;
+        get booleanValue(): boolean | undefined;
+        get numericValue(): number | undefined;
+        get rawJson(): Partial<T>;
+        get json(): T;
+        /**
+         * undefined when blob
+         */
+        get text(): string | undefined;
+    }
+    class ErrorBody<T = RestErrorResponseWrapper> extends BaseBody {
+        private data;
+        constructor(data: any);
+        get json(): T;
+        get text(): string;
+    }
+    abstract class BaseResponse<T> {
+        responseText?: string | Blob;
+        readonly headers?: RestHeaders;
+        readonly statusCode?: HttpCode | number;
+        isArray: boolean;
+        protected static readonly cookies: Cookie;
+        get cookies(): Cookie;
+        constructor(responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, isArray?: boolean);
+    }
+    class HttpResponse<T> extends BaseResponse<T> {
+        sourceRequest: Models.HandleResultSourceRequestOptions;
+        responseText?: string | Blob;
+        headers?: RestHeaders;
+        statusCode?: HttpCode | number;
+        entity?: Mapping.Mapping | Function;
+        circular?: Circ[];
+        jobid?: number;
+        isArray: boolean;
+        body: HttpBody<T>;
+        constructor(sourceRequest: Models.HandleResultSourceRequestOptions, responseText?: string | Blob, headers?: RestHeaders, statusCode?: HttpCode | number, entity?: Mapping.Mapping | Function, circular?: Circ[], jobid?: number, isArray?: boolean);
+        init(): void;
+    }
+    interface MockResponse {
+        data?: any;
+        code?: HttpCode;
+        error?: string;
+        headers?: RestHeaders;
+        jobid?: number;
+        isArray: boolean;
+    }
+    type ResponseTypeAxios = 'blob' | 'text';
+}
+declare class HttpResponseError<ERROR_BODY = object> extends Models.BaseResponse<any> {
+    message: string;
+    jobid?: number;
+    sourceRequest?: Models.HandleResultSourceRequestOptions;
+    readonly body: Models.ErrorBody<ERROR_BODY>;
+    constructor(message: string, responseText?: string, headers?: RestHeaders, statusCode?: Models.HttpCode | number, jobid?: number, sourceRequest?: Models.HandleResultSourceRequestOptions);
+}
+
+declare class Resource<E, T, TA> {
+    protected static _listenErrors: Subject<Models.BackendError>;
+    protected static _listenSuccess: Subject<Models.HttpResponse<any>>;
+    static get listenErrors(): Observable<Models.BackendError>;
+    static get listenSuccessOperations(): Observable<Models.HttpResponse<any>>;
+    static enableWarnings: boolean;
+    static initAngularNgZone(zone: any): void;
+    private checkNestedModels;
+    private static instance;
+    private static endpoints;
+    static getModel(endpoint: string, model: string): Rest<any>;
+    static request: RestRequest;
+    static create<A, TA = A[]>(e: string, model?: string, entityMapping?: Mapping.Mapping, circular?: Circ[], customContentType?: RestHeaders): Models.ResourceModel<A, TA>;
+    static reset(): void;
+    private constructor();
+    static Cookies: Cookie;
+    private static map;
+    private static prepareModel;
+    /**
+     * And enipoint to application
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {boolean}
+     */
+    private add;
+    /**
+     * Access api throught endpoint
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {Rest<T, TA>}
+     */
+    private api;
+}
+
+declare class Helpers extends CoreHelpers {
+    static JSON: typeof JSON10;
+    static get Mapping(): {
+        encode<T = Function>(json: Object, mapping: Mapping.Mapping): T;
+        decode(json: Object, autodetect?: boolean): Mapping.Mapping;
+    };
+    static checkValidUrl(url: string): boolean;
+}
+
+declare const CONTENT_TYPE: {
+    APPLICATION_JSON: RestHeaders;
+    APPLICATINO_VND_API_JSON: RestHeaders;
+};
+
+interface RestPromises<A, TA, QP extends Models.UrlParams> {
+    get: (tem?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    head: (tem?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    query: (tem?: A, queryParams?: QP) => Observable<Models.HttpResponse<TA>>;
+    put: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    patch: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    post: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A>>;
+    delete: (item?: A, queryParams?: QP) => Observable<Models.HttpResponse<A> | any>;
+}
+interface Model<A, TA, RP extends Object, QP extends Models.UrlParams> {
+    (restParams?: RP): RestPromises<A, TA, QP>;
+}
+/**
+ *
+ * @export
+ * @class SimpleResource
+ * @template A single model type
+ * @template TA array model type
+ * @template RP rest parameters type
+ * @template QP query parameters type
+ */
+declare class SimpleResource<A, TA> {
+    model: Model<A, TA, Object, Models.UrlParams>;
+    private static _isSetQueryParamsSerialization;
+    static set doNotSerializeQueryParams(value: any);
+    static __destroy(): void;
+    constructor(endpoint: string, model: string);
+}
+
+declare function interpolateParamsToUrl(params: Object, url: string): string;
+
+export { AxiosBackendHandler, CONTENT_TYPE, Helpers, HttpResponseError, Mapping, Models, Resource, Rest, RestErrorResponseWrapper, RestHeaders, RestResponseWrapper, SimpleResource, buildInterceptorChain, interpolateParamsToUrl };
+export type { AxiosTaonHttpHandler, RestHeadersOptions, TaonAxiosClientInterceptor, TaonClientMiddlewareInterceptOptions, TaonServerMiddlewareInterceptOptions };

package/lib/build-info._auto-generated_.d.ts

@@ -17,4 +17,4 @@ export declare const PROJECT_NPM_NAME = "ng2-rest";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export declare const CURRENT_PACKAGE_VERSION = "19.0.59";
+export declare const CURRENT_PACKAGE_VERSION = "21.0.4";

package/lib/build-info._auto-generated_.js

@@ -21,6 +21,6 @@ exports.PROJECT_NPM_NAME = 'ng2-rest';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-exports.CURRENT_PACKAGE_VERSION = '19.0.59';
+exports.CURRENT_PACKAGE_VERSION = '21.0.4';
 // THIS FILE IS GENERATED - DO NOT MODIFY
 //# sourceMappingURL=build-info._auto-generated_.js.map

package/lib/build-info._auto-generated_.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-info._auto-generated_.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,yCAAyC;AACzC;;GAEG;AACU,QAAA,wBAAwB,GAAG,KAAK,CAAC;AAC9C;;GAEG;AACU,QAAA,MAAM,GAAG,6BAA6B,CAAC;AACpD;;GAEG;AACU,QAAA,eAAe,GAAG,EAAE,CAAC;AAClC;;GAEG;AACU,QAAA,gBAAgB,GAAG,UAAU,CAAC;AAC3C;;GAEG;AACU,QAAA,uBAAuB,GAAG,SAAS,CAAC;AACjD,yCAAyC"}
+{"version":3,"file":"build-info._auto-generated_.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,yCAAyC;AACzC;;GAEG;AACU,QAAA,wBAAwB,GAAG,KAAK,CAAC;AAC9C;;GAEG;AACU,QAAA,MAAM,GAAG,6BAA6B,CAAC;AACpD;;GAEG;AACU,QAAA,eAAe,GAAG,EAAE,CAAC;AAClC;;GAEG;AACU,QAAA,gBAAgB,GAAG,UAAU,CAAC;AAC3C;;GAEG;AACU,QAAA,uBAAuB,GAAG,QAAQ,CAAC;AAChD,yCAAyC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng2-rest",
-  "version": "19.0.59",
+  "version": "21.0.4",
   "scripts": {
     "taon init": "taon init",
     "taon start": "taon start",
@@ -30,14 +30,14 @@
     "url": "https://github.com/darekf77/ng2-rest/issues"
   },
   "dependencies": {
-    "@types/diff": "~5.2.1",
+    "@types/diff": "~5.2.3",
     "diff": "~4.0.2",
-    "axios": "~1.8.4",
+    "axios": "~1.13.2",
     "lodash": "~4.17.21",
     "@types/lodash": "4.14.92",
-    "ng2-logger": "~19.0.0",
+    "ng2-logger": "~21.0.0",
     "json5": "~2.2.3",
-    "json10": "~19.0.0"
+    "json10": "~21.0.0"
   },
   "description": "Description for ng2-rest. Hello world!",
   "keywords": [