@kontent-ai/delivery-sdk 12.0.0-0

package/lib/services/base-delivery-query.service.ts

@@ -0,0 +1,335 @@
+import { IResponse, IHeader, IHttpService, IQueryParameter, urlHelper } from '@kontent-ai/core-sdk';
+import { AxiosError } from 'axios';
+import {
+    waitForLoadingNewContentHeader,
+    IQueryConfig,
+    ISDKInfo,
+    IDeliveryErrorRaw,
+    DeliveryError,
+    sdkVersionHeader,
+    staleContentHeaderName,
+    continuationTokenHeaderName,
+    IDeliveryNetworkResponse
+} from '../models';
+
+import { IDeliveryClientConfig } from '../config';
+import { IMappingService } from './mapping.service';
+
+export abstract class BaseDeliveryQueryService {
+    /**
+     * Default base Url to Kontent.ai Delivery API
+     */
+    private readonly defaultBaseDeliveryApiUrl: string = 'https://deliver.kontent.ai';
+
+    /**
+     * Default preview url to Kontent.ai Delivery API
+     */
+    private readonly defaultPreviewDeliveryApiUrl: string = 'https://preview-deliver.kontent.ai';
+
+    constructor(
+        /**
+         * Delivery client configuration
+         */
+        public readonly config: IDeliveryClientConfig,
+        /**
+         * Http service for fetching data
+         */
+        public readonly httpService: IHttpService<any>,
+        /**
+         * Information about the SDK
+         */
+         public readonly sdkInfo: ISDKInfo,
+        /**
+         * Mapping service
+         */
+        public readonly mappingService: IMappingService
+    ) {}
+
+    /**
+     * Gets url based on the action, query configuration and options (parameters)
+     * @param action Action (= url part) that will be hit
+     * @param queryConfig Query configuration
+     * @param options Query options
+     */
+    getUrl(action: string, queryConfig: IQueryConfig, options?: IQueryParameter[]): string {
+        if (!this.config.proxy || !this.config.proxy.advancedProxyUrlResolver) {
+            return urlHelper.addOptionsToUrl(this.getBaseUrl(queryConfig) + action, options);
+        }
+        return this.config.proxy.advancedProxyUrlResolver({
+            queryParameters: options ? options : [],
+            queryString: urlHelper.addOptionsToUrl('', options),
+            action: action,
+            domain: this.getDomain(queryConfig),
+            queryConfig: queryConfig,
+            projectId: this.config.projectId
+        });
+    }
+
+    /**
+     * Gets proper set of headers for given request.
+     * @param queryConfig Query configuration
+     * @param additionalHeaders Custom headers
+     */
+    getHeaders(queryConfig: IQueryConfig, additionalHeaders?: IHeader[]): IHeader[] {
+        const headers: IHeader[] = [];
+
+        if (additionalHeaders) {
+            headers.push(...additionalHeaders);
+        }
+
+        // add SDK Id header for monitoring SDK usage
+        headers.push(this.getSdkIdHeader());
+
+        // add headers from global config
+        if (this.config.globalHeaders) {
+            headers.push(...this.config.globalHeaders(queryConfig));
+        }
+
+        // add query / global headers from query config
+        headers.push(...this.getQueryHeaders(queryConfig));
+
+        if (this.isPreviewModeEnabled(queryConfig) && this.isSecuredModeEnabled(queryConfig)) {
+            throw Error(`Preview & secured modes cannot be used at the same time.`);
+        }
+
+        // add preview header is required
+        if (this.isPreviewModeEnabled(queryConfig) && this.config.previewApiKey) {
+            headers.push(this.getAuthorizationHeader(this.config.previewApiKey));
+        }
+
+        // add secured mode header is required
+        if (this.isSecuredModeEnabled(queryConfig) && this.config.secureApiKey) {
+            headers.push(this.getAuthorizationHeader(this.config.secureApiKey));
+        }
+
+        // add 'X-KC-Wait-For-Loading-New-Content' header if required
+        if (this.shouldAddWaitForLoadingNewContentHeader(queryConfig)) {
+            headers.push({
+                header: waitForLoadingNewContentHeader,
+                value: 'true'
+            });
+        }
+
+        return headers;
+    }
+
+    /**
+     * Http GET response
+     * @param url Url of request
+     * @param queryConfig Query config configuration
+     */
+    protected async getResponseAsync<TRawData>(
+        url: string,
+        queryConfig?: IQueryConfig,
+        serviceConfig?: {
+            headers?: IHeader[];
+        }
+    ): Promise<IResponse<TRawData>> {
+        if (!queryConfig) {
+            queryConfig = {};
+        }
+
+        if (!serviceConfig) {
+            serviceConfig = {};
+        }
+
+        try {
+            return await this.httpService.getAsync<TRawData>(
+                {
+                    url: url
+                },
+                {
+                    cancelToken: queryConfig?.cancelToken,
+                    responseType: 'json',
+                    retryStrategy: this.config.retryStrategy,
+                    headers: this.getHeaders(queryConfig, serviceConfig.headers ? serviceConfig.headers : [])
+                }
+            );
+        } catch (error) {
+            throw this.mapDeliveryError(error);
+        }
+    }
+
+    /**
+     * Gets base URL of the request including the project Id
+     * @param queryConfig Query configuration
+     */
+    protected getBaseUrl(queryConfig: IQueryConfig): string {
+        return this.getDomain(queryConfig) + '/' + this.config.projectId;
+    }
+
+    protected mapNetworkResponse<TData, TContract>(
+        data: TData,
+        response: IResponse<any>
+    ): IDeliveryNetworkResponse<TData, TContract> {
+        return {
+            data: data,
+            response: response,
+            hasStaleContent: this.getHasStaleContent(response.headers),
+            xContinuationToken: this.getContinuationToken(response.headers)
+        };
+    }
+
+    /**
+     * Indicates if current query should use preview mode
+     * @param queryConfig Query configuration
+     */
+    private isPreviewModeEnabled(queryConfig: IQueryConfig): boolean {
+        if (queryConfig.usePreviewMode !== undefined) {
+            return queryConfig.usePreviewMode;
+        }
+
+        if (!this.config.defaultQueryConfig) {
+            return false;
+        }
+
+        if (this.config.defaultQueryConfig.usePreviewMode === true) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private getQueryHeaders(queryConfig: IQueryConfig): IHeader[] {
+        if (queryConfig.customHeaders) {
+            return queryConfig.customHeaders;
+        }
+
+        if (this.config.defaultQueryConfig?.customHeaders) {
+            return this.config.defaultQueryConfig.customHeaders;
+        }
+
+        return [];
+    }
+
+    private shouldAddWaitForLoadingNewContentHeader(queryConfig: IQueryConfig): boolean {
+        if (queryConfig.waitForLoadingNewContent !== undefined) {
+            return queryConfig.waitForLoadingNewContent;
+        }
+
+        if (!this.config.defaultQueryConfig) {
+            return false;
+        }
+
+        if (this.config.defaultQueryConfig.waitForLoadingNewContent === true) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Indicates if current query should use secured mode
+     * @param queryConfig Query configuration
+     */
+    private isSecuredModeEnabled(queryConfig: IQueryConfig): boolean {
+        if (queryConfig.useSecuredMode !== undefined) {
+            return queryConfig.useSecuredMode;
+        }
+
+        if (!this.config.defaultQueryConfig) {
+            return false;
+        }
+
+        if (this.config.defaultQueryConfig.useSecuredMode === true) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Gets preview or standard URL based on client and query configuration
+     * @param queryConfig Query configuration
+     */
+    private getDomain(queryConfig: IQueryConfig): string {
+        if (this.isPreviewModeEnabled(queryConfig)) {
+            if (!this.config.previewApiKey) {
+                throw Error(`Preview API key is not configured.`);
+            }
+
+            // check custom preview url
+            if (this.config.proxy && this.config.proxy.basePreviewUrl) {
+                return this.config.proxy.basePreviewUrl;
+            }
+
+            // use default preview url
+            return this.defaultPreviewDeliveryApiUrl;
+        }
+
+        // check custom base url
+        if (this.config.proxy && this.config.proxy.baseUrl) {
+            return this.config.proxy.baseUrl;
+        }
+        return this.defaultBaseDeliveryApiUrl;
+    }
+
+    /**
+     * Gets authorization header. This is used for 'preview' functionality
+     */
+    private getAuthorizationHeader(key?: string): IHeader {
+        if (!key) {
+            throw Error(`Cannot get authorization header because key is invalid`);
+        }
+        // authorization header required for preview mode
+        return {
+            header: 'authorization',
+            value: `bearer ${key}`
+        };
+    }
+
+    /**
+     * Header identifying SDK type & version for internal purposes of Kontent.ai
+     */
+    private getSdkIdHeader(): IHeader {
+        return {
+            header: sdkVersionHeader,
+            value: `${this.sdkInfo.host};${this.sdkInfo.name};${this.sdkInfo.version}`
+        };
+    }
+
+    private mapDeliveryError(error: any): DeliveryError | any {
+        let axiosError: AxiosError | undefined;
+
+        if (error.error) {
+            axiosError = error.error;
+        } else {
+            axiosError = error;
+        }
+
+        if (!axiosError || !axiosError.isAxiosError) {
+            return error;
+        }
+
+        const deliveryErrorData = axiosError.response?.data as IDeliveryErrorRaw;
+
+        if (!deliveryErrorData || !deliveryErrorData.error_code) {
+            return error;
+        }
+
+        return new DeliveryError({
+            errorCode: deliveryErrorData.error_code,
+            message: deliveryErrorData.message,
+            specificCode: deliveryErrorData.specific_code,
+            requestId: deliveryErrorData.request_id
+        });
+    }
+
+    private getHasStaleContent(headers: IHeader[]): boolean {
+        const hasStaleContentHeader = headers.find(
+            (m) => m.header.toLowerCase() === staleContentHeaderName.toLowerCase()
+        );
+
+        if (hasStaleContentHeader) {
+            if (hasStaleContentHeader.value.toString() === '1') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private getContinuationToken(headers: IHeader[]): string | undefined {
+        const header = headers.find((m) => m.header.toLowerCase() === continuationTokenHeaderName.toLowerCase());
+        return header ? header.value : undefined;
+    }
+}

package/lib/services/delivery-query.service.ts

@@ -0,0 +1,259 @@
+import { IHttpService } from '@kontent-ai/core-sdk';
+
+import { IDeliveryClientConfig } from '../config';
+import {
+    Contracts
+} from '../contracts';
+import {
+    Responses,
+    IContentItem,
+    IContentTypeQueryConfig,
+    IGroupedNetworkResponse,
+    IItemQueryConfig,
+    IDeliveryNetworkResponse,
+    ILanguagesQueryConfig,
+    ITaxonomyQueryConfig
+} from '../models';
+import {
+    IKontentListAllResponse,
+    IKontentListResponse,
+    IListAllQueryConfig,
+    ISDKInfo
+} from '../models/common/common-models';
+import { BaseDeliveryQueryService } from './base-delivery-query.service';
+import { IMappingService } from './mapping.service';
+
+export class QueryService extends BaseDeliveryQueryService {
+    constructor(
+        config: IDeliveryClientConfig,
+        httpService: IHttpService<any>,
+        sdkInfo: ISDKInfo,
+        mappingService: IMappingService
+    ) {
+        super(config, httpService, sdkInfo, mappingService);
+    }
+
+    /**
+     * Gets single item from given url
+     * @param url Url used to get single item
+     * @param queryConfig Query configuration
+     */
+    async getSingleItemAsync<TContentItem extends IContentItem = IContentItem>(
+        url: string,
+        queryConfig: IItemQueryConfig
+    ): Promise<
+        IDeliveryNetworkResponse<Responses.IViewContentItemResponse<TContentItem>, Contracts.IViewContentItemContract>
+    > {
+        const response = await this.getResponseAsync<Contracts.IViewContentItemContract>(url, queryConfig);
+
+        return this.mapNetworkResponse<
+            Responses.IViewContentItemResponse<TContentItem>,
+            Contracts.IViewContentItemContract
+        >(this.mappingService.viewContentItemResponse<TContentItem>(response.data), response);
+    }
+
+    /**
+     * Gets single feed response. Might not contain all items in your project.
+     * @param url Url
+     * @param queryConfig Query configuration
+     */
+    async getItemsFeed<TContentItem extends IContentItem = IContentItem>(
+        url: string,
+        queryConfig: IItemQueryConfig
+    ): Promise<IDeliveryNetworkResponse<Responses.IListItemsFeedResponse<TContentItem>, Contracts.IItemsFeedContract>> {
+        const response = await this.getResponseAsync<Contracts.IItemsFeedContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.itemsFeedResponse<TContentItem>(response.data), response);
+    }
+
+    /**
+     * Gets multiple items from given url
+     * @param url Url used to get multiple items
+     * @param queryConfig Query configuration
+     */
+    async getMultipleItems<TContentItem extends IContentItem = IContentItem>(
+        url: string,
+        queryConfig: IItemQueryConfig
+    ): Promise<
+        IDeliveryNetworkResponse<Responses.IListContentItemsResponse<TContentItem>, Contracts.IListContentItemsContract>
+    > {
+        const response = await this.getResponseAsync<Contracts.IListContentItemsContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.listContentItemsResponse(response.data), response);
+    }
+
+    /**
+     * Gets single content type from given url
+     * @param url Url used to get single type
+     * @param queryConfig Query configuration
+     */
+    async getSingleType(
+        url: string,
+        queryConfig: IContentTypeQueryConfig
+    ): Promise<IDeliveryNetworkResponse<Responses.IViewContentTypeResponse, Contracts.IViewContentTypeContract>> {
+        const response = await this.getResponseAsync<Contracts.IViewContentTypeContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.viewContentTypeResponse(response.data), response);
+    }
+
+    /**
+     * Gets multiple content types from given url
+     * @param url Url used to get multiple types
+     * @param queryConfig Query configuration
+     */
+    async getMultipleTypes(
+        url: string,
+        queryConfig: IContentTypeQueryConfig
+    ): Promise<IDeliveryNetworkResponse<Responses.IListContentTypesResponse, Contracts.IListContentTypeContract>> {
+        const response = await this.getResponseAsync<Contracts.IListContentTypeContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.listContentTypesResponse(response.data), response);
+    }
+
+    /**
+     * Gets languages
+     * @param url Url
+     * @param queryConfig Query configuration
+     */
+    async getLanguages(
+        url: string,
+        queryConfig: ILanguagesQueryConfig
+    ): Promise<IDeliveryNetworkResponse<Responses.IListLanguagesResponse, Contracts.IListLanguagesContract>> {
+        const response = await this.getResponseAsync<Contracts.IListLanguagesContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.listLanguagesResponse(response.data), response);
+    }
+
+    /**
+     * Gets single taxonomy from given url
+     * @param url Url used to get single taxonomy
+     * @param queryConfig Query configuration
+     */
+    async getTaxonomy(
+        url: string,
+        queryConfig: ITaxonomyQueryConfig
+    ): Promise<IDeliveryNetworkResponse<Responses.IViewTaxonomyResponse, Contracts.IViewTaxonomyGroupContract>> {
+        const response = await this.getResponseAsync<Contracts.IViewTaxonomyGroupContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.viewTaxonomyResponse(response.data), response);
+    }
+
+    /**
+     * Gets multiple taxonomies from given url
+     * @param url Url used to get multiple taxonomies
+     * @param queryConfig Query configuration
+     */
+    async getTaxonomies(
+        url: string,
+        queryConfig: ITaxonomyQueryConfig
+    ): Promise<IDeliveryNetworkResponse<Responses.IListTaxonomiesResponse, Contracts.IListTaxonomyGroupsContract>> {
+        const response = await this.getResponseAsync<Contracts.IListTaxonomyGroupsContract>(url, queryConfig);
+
+        return this.mapNetworkResponse(this.mappingService.listTaxonomiesResponse(response.data), response);
+    }
+
+    /**
+     * Gets single content type element from given url
+     * @param url Url used to get single content type element
+     * @param queryConfig Query configuration
+     */
+    async getElementAsync(
+        url: string,
+        queryConfig: ITaxonomyQueryConfig
+    ): Promise<
+        IDeliveryNetworkResponse<Responses.IViewContentTypeElementResponse, Contracts.IViewContentTypeElementContract>
+    > {
+        const response = await this.getResponseAsync<Contracts.IViewContentTypeElementContract>(
+            url,
+            queryConfig
+        );
+
+        return this.mapNetworkResponse(this.mappingService.viewContentTypeElementResponse(response.data), response);
+    }
+
+    async getListAllResponse<
+        TResponse extends IKontentListResponse,
+        TAllResponse extends IKontentListAllResponse,
+        TContract
+    >(data: {
+        page: number;
+        getResponse: (
+            nextPageUrl?: string,
+            continuationToken?: string
+        ) => Promise<IDeliveryNetworkResponse<TResponse, TContract>>;
+        allResponseFactory: (
+            items: any[],
+            responses: IDeliveryNetworkResponse<TResponse, TContract>[]
+        ) => IGroupedNetworkResponse<TAllResponse>;
+        listQueryConfig?: IListAllQueryConfig<TResponse, TContract>;
+    }): Promise<IGroupedNetworkResponse<TAllResponse>> {
+        const responses = await this.getListAllResponseInternalAsync({
+            page: data.page,
+            resolvedResponses: [],
+            getResponse: data.getResponse,
+            nextPageUrl: undefined,
+            continuationToken: undefined,
+            listQueryConfig: data.listQueryConfig
+        });
+
+        return data.allResponseFactory(
+            responses.reduce((prev: any[], current) => {
+                prev.push(...current.data.items);
+                return prev;
+            }, []),
+            responses
+        );
+    }
+
+    private async getListAllResponseInternalAsync<TResponse extends IKontentListResponse, TContract>(data: {
+        page: number;
+        nextPageUrl?: string;
+        continuationToken?: string;
+        getResponse: (
+            nextPageUrl?: string,
+            continuationToken?: string
+        ) => Promise<IDeliveryNetworkResponse<TResponse, TContract>>;
+        resolvedResponses: IDeliveryNetworkResponse<TResponse, TContract>[];
+        listQueryConfig?: IListAllQueryConfig<TResponse, TContract>;
+    }): Promise<IDeliveryNetworkResponse<TResponse, TContract>[]> {
+        if (data.listQueryConfig?.pages) {
+            if (data.page > data.listQueryConfig.pages) {
+                // page limit reached, return result
+                return data.resolvedResponses;
+            }
+        }
+
+        const response = await data.getResponse(data.nextPageUrl, data.continuationToken);
+
+        if (data.listQueryConfig?.delayBetweenRequests) {
+            await this.sleep(data.listQueryConfig.delayBetweenRequests);
+        }
+
+        data.resolvedResponses.push(response);
+
+        if (data.listQueryConfig?.responseFetched) {
+            data.listQueryConfig.responseFetched(response, data.nextPageUrl, data.continuationToken);
+        }
+
+        const nextPage = response.data.pagination?.nextPage;
+        const continuationToken = response.xContinuationToken;
+
+        if (nextPage || continuationToken) {
+            // recursively fetch next page data
+            return await this.getListAllResponseInternalAsync({
+                page: data.page + 1,
+                nextPageUrl: nextPage,
+                continuationToken: continuationToken,
+                listQueryConfig: data.listQueryConfig,
+                getResponse: data.getResponse,
+                resolvedResponses: data.resolvedResponses
+            });
+        }
+
+        return data.resolvedResponses;
+    }
+
+    private sleep(ms: number): Promise<void> {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/lib/services/index.ts

@@ -0,0 +1,2 @@
+export * from './delivery-query.service';
+export * from './mapping.service';