@anglr/rest/es2022/src/misc/utils.js

Angular module representing rest services

import { HttpParams } from '@angular/common/http';
import { isPresent } from '@jscrpt/common';
import { NotType } from './classes/notType';
/**
 * Builds and returns array of middleware run functions
 * @param middlewares - Array of set middleware types
 * @param middlewaresOrder - Array of middleware types in order that should be executed
 */
export const buildMiddlewares = function buildMiddlewares(middlewares, middlewaresOrder) {
    const usedMiddlewares = [];
    middlewares
        .filter(middleware => !isNotType(middleware))
        .forEach(middleware => {
        const type = getType(middleware);
        const index = middlewaresOrder.findIndex(itm => itm == type || type.id == itm);
        //middleware does not have defined order
        if (index < 0) {
            return;
        }
        usedMiddlewares[index] = type;
    });
    //removes not middlewares
    middlewares
        .filter(middleware => isNotType(middleware))
        .forEach(middleware => {
        const type = getType(middleware);
        const index = middlewaresOrder.findIndex(itm => itm == type || type.id == itm);
        if (index < 0) {
            return;
        }
        usedMiddlewares.splice(index, 1, undefined);
    });
    const runMethods = [];
    usedMiddlewares.forEach(middleware => {
        if (middleware) {
            runMethods.push(new middleware().run);
        }
    });
    return runMethods;
};
/**
 * Creates NotType from Type, this type will be removed from middlewares
 * @param type - Type that will be set as NotType
 */
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function not(type) {
    return new NotType(type);
}
/**
 * Gets underlying type for Type and NotType
 * @param type - Type that is going to be used for extraction
 */
export function getType(type) {
    if (type instanceof NotType) {
        return type.ɵtype;
    }
    return type;
}
/**
 * Tests whether is provided type NotType
 * @param type - Type to be tested for NotType
 */
export function isNotType(type) {
    return type instanceof NotType;
}
/**
 * Handles query param and fills params dictionary
 * @param data - Data for creating query param
 * @param params - Params where should be new value placed
 * @param args - Array of all arguments passed to handled function
 */
export async function handleQueryParam(data, params, args) {
    //apply parameter transform
    if (data.transformFn) {
        data.value = await data.transformFn(data.value, ...args);
    }
    // if the value is a instance of Object, we stringify it
    if (data.value instanceof Object) {
        data.value = JSON.stringify(data.value);
    }
    //only non null and non undefined values
    if (isPresent(data.value)) {
        params[data.key] = data.value;
    }
}
/**
 * Handles header param and fills headers dictionary
 * @param data - Data for creating header param
 * @param headers - Params where should be new value placed
 * @param args - Array of all arguments passed to handled function
 */
export async function handleHeaderParam(data, headers, args) {
    //apply parameter transform
    if (data.transformFn) {
        data.value = await data.transformFn(data.value, ...args);
    }
    //only non null and non undefined values
    if (isPresent(data.value)) {
        headers[data.key] = data.value;
    }
}
/**
 * Handles path param and return updated url
 * @param data - Data for creating path param
 * @param url - Current url to be updated
 * @param args - Array of all arguments passed to handled function
 */
export async function handlePathParam(data, url, args) {
    //apply parameter transform
    if (data.transformFn) {
        data.value = await data.transformFn(data.value, ...args);
    }
    return url.replace('{' + data.key + '}', data.value ?? '');
}
/**
 * Handles query object param and fills serialized query string array
 * @param data - Data for creating query object param
 * @param queryStrings - Array of query serialized query strings
 * @param querySerializer - Serializer for query object
 * @param args - Array of all arguments passed to handled function
 */
export async function handleQueryObjectParam(data, queryStrings, querySerializer, args) {
    //apply parameter transform
    if (data.transformFn) {
        data.value = await data.transformFn(data.value, ...args);
    }
    const serializedObj = querySerializer.serializeObject(data.value);
    if (serializedObj) {
        queryStrings.push(serializedObj);
    }
}
/**
 * Merges serialized query objects data with existing http params
 * @param queryStrings - Serialized query objects data
 * @param requestParams - Existing http params to be merged with
 */
export function mergeQueryObjectParamsWithHttpParams(queryStrings, requestParams) {
    const queryString = queryStrings.join('&');
    const params = new HttpParams({ fromString: queryString });
    params.keys().forEach(key => {
        const newValues = params.getAll(key);
        if (newValues) {
            newValues.forEach((value, index) => {
                //first item, set
                if (!index) {
                    requestParams = requestParams.set(key, value);
                }
                //rest append
                else {
                    requestParams = requestParams.append(key, value);
                }
            });
        }
    });
    return requestParams;
}
//# sourceMappingURL=utils.js.map