@kontent-ai/delivery-sdk 16.4.3 → 17.0.0-preview.1

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

@@ -1,336 +0,0 @@
-import { IHttpService } from '@kontent-ai/core-sdk';
-import { IDeliveryClientConfig } from '../config';
-import { Contracts } from '../contracts';
-import {
-    Responses,
-    IContentItem,
-    IContentTypeQueryConfig,
-    IGroupedNetworkResponse,
-    IItemQueryConfig,
-    IDeliveryNetworkResponse,
-    ILanguagesQueryConfig,
-    ITaxonomyQueryConfig,
-    ISyncInitQueryConfig,
-    ClientTypes
-} 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<TClientTypes extends ClientTypes> extends BaseDeliveryQueryService<TClientTypes> {
-    constructor(
-        config: IDeliveryClientConfig,
-        httpService: IHttpService<any>,
-        sdkInfo: ISDKInfo,
-        mappingService: IMappingService<TClientTypes>
-    ) {
-        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 = TClientTypes['contentItemType']>(
-        url: string,
-        queryConfig: IItemQueryConfig
-    ): Promise<
-        IDeliveryNetworkResponse<
-            Responses.IViewContentItemResponse<TContentItem, TClientTypes['contentItemType']>,
-            Contracts.IViewContentItemContract
-        >
-    > {
-        const response = await this.getResponseAsync<Contracts.IViewContentItemContract>(url, queryConfig);
-
-        return this.mapNetworkResponse<
-            Responses.IViewContentItemResponse<TContentItem, TClientTypes['contentItemType']>,
-            Contracts.IViewContentItemContract
-        >(this.mappingService.viewContentItemResponse<TContentItem>(response.data), response);
-    }
-
-    /**
-     * Gets single feed response. Might not contain all items in your environment.
-     * @param url Url
-     * @param queryConfig Query configuration
-     */
-    async getItemsFeed<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        url: string,
-        queryConfig: IItemQueryConfig
-    ): Promise<
-        IDeliveryNetworkResponse<
-            Responses.IListItemsFeedResponse<TContentItem, TClientTypes['contentItemType']>,
-            Contracts.IItemsFeedContract
-        >
-    > {
-        const response = await this.getResponseAsync<Contracts.IItemsFeedContract>(url, queryConfig);
-
-        return this.mapNetworkResponse(this.mappingService.itemsFeedResponse<TContentItem>(response.data), response);
-    }
-
-    /**
-     * Gets single used in response. Might not contain all used in references.
-     * @param url Url
-     * @param queryConfig Query configuration
-     */
-    async getUsedIn(
-        url: string,
-        queryConfig: IItemQueryConfig
-    ): Promise<IDeliveryNetworkResponse<Responses.IUsedInResponse<TClientTypes>, Contracts.IUsedInItemsContract>> {
-        const response = await this.getResponseAsync<Contracts.IUsedInItemsContract>(url, queryConfig);
-
-        return this.mapNetworkResponse(this.mappingService.usedInResponse(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 = TClientTypes['contentItemType']>(
-        url: string,
-        queryConfig: IItemQueryConfig
-    ): Promise<
-        IDeliveryNetworkResponse<
-            Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']>,
-            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<TClientTypes['contentTypeCodenames']>,
-            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<TClientTypes['contentTypeCodenames']>,
-            Contracts.IListContentTypeContract
-        >
-    > {
-        const response = await this.getResponseAsync<Contracts.IListContentTypeContract>(url, queryConfig);
-
-        return this.mapNetworkResponse(this.mappingService.listContentTypesResponse(response.data), response);
-    }
-
-    /**
-     * Initializes synchronization of changes in content items based on the specified parameters. After the initialization,
-     * you'll get an X-Continuation token in the response.
-     * Use the token to synchronize changes in the content items matching the initialization criteria.
-     * @param url Url
-     * @param queryConfig Query configuration
-     */
-    async initializeSync(
-        url: string,
-        queryConfig: ISyncInitQueryConfig
-    ): Promise<IDeliveryNetworkResponse<Responses.IInitializeSyncResponse, Contracts.IInitializeSyncContract>> {
-        const response = await this.postResponseAsync<Contracts.IInitializeSyncContract>(url, {}, queryConfig);
-
-        return this.mapNetworkResponse(this.mappingService.initializeContentSync(response.data), response);
-    }
-
-    /**
-     * Retrieve a list of delta updates to recently changed content items in the specified environment.
-     * The types of items you get is determined by the X-Continuation token you use.
-     * @param url Url used to get multiple types
-     * @param queryConfig Query configuration
-     */
-    async syncChanges(
-        url: string,
-        queryConfig: IContentTypeQueryConfig
-    ): Promise<IDeliveryNetworkResponse<Responses.ISyncChangesResponse, Contracts.ISyncChangesContract>> {
-        const response = await this.getResponseAsync<Contracts.ISyncChangesContract>(url, queryConfig);
-
-        return this.mapNetworkResponse(this.mappingService.syncChanges(response.data), response);
-    }
-
-    /**
-     * Gets languages
-     * @param url Url
-     * @param queryConfig Query configuration
-     */
-    async getLanguages(
-        url: string,
-        queryConfig: ILanguagesQueryConfig
-    ): Promise<
-        IDeliveryNetworkResponse<
-            Responses.IListLanguagesResponse<TClientTypes['languageCodenames']>,
-            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<TClientTypes['taxonomyCodenames']>,
-            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<TClientTypes['taxonomyCodenames']>,
-            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

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

package/lib/services/mapping.service.ts

@@ -1,223 +0,0 @@
-import { IDeliveryClientConfig } from '../config';
-import { Contracts } from '../contracts';
-import {
-    SyncMapper,
-    GenericElementMapper,
-    ItemMapper,
-    LanguageMapper,
-    TaxonomyMapper,
-    TypeMapper,
-    UsedInMapper
-} from '../mappers';
-import { Responses, IContentItem, IPagination, ClientTypes } from '../models';
-
-export interface IMappingService<TClientTypes extends ClientTypes> {
-    listContentTypesResponse(
-        data: Contracts.IListContentTypeContract
-    ): Responses.IListContentTypesResponse<TClientTypes['contentTypeCodenames']>;
-
-    itemsFeedResponse<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        data: Contracts.IItemsFeedContract
-    ): Responses.IListItemsFeedResponse<TContentItem, TClientTypes['contentItemType']>;
-
-    usedInResponse(data: Contracts.IUsedInItemsContract): Responses.IUsedInResponse<TClientTypes>;
-
-    viewContentTypeResponse(
-        data: Contracts.IViewContentTypeContract
-    ): Responses.IViewContentTypeResponse<TClientTypes['contentTypeCodenames']>;
-
-    viewContentItemResponse<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        data: Contracts.IViewContentItemContract
-    ): Responses.IViewContentItemResponse<TContentItem, TClientTypes['contentItemType']>;
-
-    listContentItemsResponse<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        data: Contracts.IListContentItemsContract
-    ): Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']>;
-
-    viewTaxonomyResponse(
-        data: Contracts.IViewTaxonomyGroupContract
-    ): Responses.IViewTaxonomyResponse<TClientTypes['taxonomyCodenames']>;
-
-    listTaxonomiesResponse(
-        data: Contracts.IListTaxonomyGroupsContract
-    ): Responses.IListTaxonomiesResponse<TClientTypes['taxonomyCodenames']>;
-
-    viewContentTypeElementResponse(
-        data: Contracts.IViewContentTypeElementContract
-    ): Responses.IViewContentTypeElementResponse;
-
-    listLanguagesResponse(
-        data: Contracts.IListLanguagesContract
-    ): Responses.IListLanguagesResponse<TClientTypes['languageCodenames']>;
-    initializeContentSync(data: Contracts.IInitializeSyncContract): Responses.IInitializeSyncResponse;
-    syncChanges(data: Contracts.ISyncChangesContract): Responses.ISyncChangesResponse;
-}
-
-export class MappingService<TClientTypes extends ClientTypes> implements IMappingService<TClientTypes> {
-    private readonly typeMapper: TypeMapper<TClientTypes['contentTypeCodenames']>;
-    private readonly languageMapper: LanguageMapper<TClientTypes['languageCodenames']>;
-    private readonly itemMapper: ItemMapper<TClientTypes['contentItemType']>;
-    private readonly taxonomyMapper: TaxonomyMapper<TClientTypes['taxonomyCodenames']>;
-    private readonly usedInMapper: UsedInMapper<TClientTypes>;
-    private readonly genericElementMapper: GenericElementMapper;
-    private readonly syncMapper: SyncMapper;
-
-    constructor(readonly config: IDeliveryClientConfig) {
-        this.typeMapper = new TypeMapper();
-        this.languageMapper = new LanguageMapper();
-        this.itemMapper = new ItemMapper(config);
-        this.taxonomyMapper = new TaxonomyMapper();
-        this.usedInMapper = new UsedInMapper<TClientTypes>();
-        this.genericElementMapper = new GenericElementMapper();
-        this.syncMapper = new SyncMapper();
-    }
-
-    usedInResponse(data: Contracts.IUsedInItemsContract): Responses.IUsedInResponse<TClientTypes> {
-        return {
-            items: data.items.map((m) => this.usedInMapper.mapUsedInItem(m))
-        };
-    }
-
-    /**
-     * Gets response for list of languages
-     * @param data Response data
-     */
-    listLanguagesResponse(
-        data: Contracts.IListLanguagesContract
-    ): Responses.IListLanguagesResponse<TClientTypes['languageCodenames']> {
-        return {
-            items: this.languageMapper.mapMultipleLanguages(data),
-            pagination: this.mapPagination(data.pagination)
-        };
-    }
-
-    /**
-     * Gets response for getting a multiple type
-     * @param data Response data
-     */
-    listContentTypesResponse(
-        data: Contracts.IListContentTypeContract
-    ): Responses.IListContentTypesResponse<TClientTypes['contentTypeCodenames']> {
-        return {
-            items: this.typeMapper.mapMultipleTypes(data),
-            pagination: this.mapPagination(data.pagination)
-        };
-    }
-
-    /**
-     * Gets response for single type
-     * @param data Response data
-     * @param options Options
-     */
-    viewContentTypeResponse(
-        data: Contracts.IViewContentTypeContract
-    ): Responses.IViewContentTypeResponse<TClientTypes['contentTypeCodenames']> {
-        return {
-            type: this.typeMapper.mapSingleType(data)
-        };
-    }
-
-    itemsFeedResponse<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        data: Contracts.IItemsFeedContract
-    ): Responses.IListItemsFeedResponse<TContentItem, TClientTypes['contentItemType']> {
-        const itemsResult = this.itemMapper.mapItems<TContentItem>({
-            linkedItems: Object.values(data.modular_content),
-            mainItems: data.items
-        });
-
-        return {
-            items: itemsResult.items,
-            linkedItems: itemsResult.linkedItems
-        };
-    }
-
-    /**
-     * Gets response for getting single item
-     * @param data Response data
-     * @param queryConfig Query configuration
-     */
-    viewContentItemResponse<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        data: Contracts.IViewContentItemContract
-    ): Responses.IViewContentItemResponse<TContentItem, TClientTypes['contentItemType']> {
-        const itemResult = this.itemMapper.mapSingleItemFromResponse<TContentItem>(data);
-
-        return {
-            item: itemResult.item,
-            linkedItems: itemResult.linkedItems
-        };
-    }
-
-    /**
-     * Gets response for getting multiple items
-     * @param data Response data
-     * @param queryConfig Query configuration
-     */
-    listContentItemsResponse<TContentItem extends IContentItem = TClientTypes['contentItemType']>(
-        data: Contracts.IListContentItemsContract
-    ): Responses.IListContentItemsResponse<TContentItem, TClientTypes['contentItemType']> {
-        const itemsResult = this.itemMapper.mapMultipleItemsFromResponse<TContentItem>(data);
-
-        return {
-            items: itemsResult.items,
-            pagination: this.mapPagination(data.pagination),
-            linkedItems: itemsResult.linkedItems
-        };
-    }
-
-    /**
-     * Gets response for getting single taxonomy item
-     * @param data Response data
-     */
-    viewTaxonomyResponse(
-        data: Contracts.IViewTaxonomyGroupContract
-    ): Responses.IViewTaxonomyResponse<TClientTypes['taxonomyCodenames']> {
-        return {
-            taxonomy: this.taxonomyMapper.mapTaxonomy(data.system, data.terms)
-        };
-    }
-
-    /**
-     * Gets response for getting multiples taxonomies
-     * @param data Response data
-     */
-    listTaxonomiesResponse(
-        data: Contracts.IListTaxonomyGroupsContract
-    ): Responses.IListTaxonomiesResponse<TClientTypes['taxonomyCodenames']> {
-        return {
-            items: this.taxonomyMapper.mapTaxonomies(data.taxonomies),
-            pagination: this.mapPagination(data.pagination)
-        };
-    }
-
-    /**
-     * Gets response for getting single content type element
-     * @param data Response data
-     */
-    viewContentTypeElementResponse(
-        data: Contracts.IViewContentTypeElementContract
-    ): Responses.IViewContentTypeElementResponse {
-        return this.genericElementMapper.mapElement(data);
-    }
-
-    initializeContentSync(data: Contracts.IInitializeSyncContract): Responses.IInitializeSyncResponse {
-        return {
-            items: data.items.map((m) => this.syncMapper.mapContentItemDelta(m))
-        };
-    }
-
-    syncChanges(data: Contracts.ISyncChangesContract): Responses.ISyncChangesResponse {
-        return {
-            items: data.items.map((m) => this.syncMapper.mapContentItemDelta(m))
-        };
-    }
-
-    private mapPagination(paginationContract: Contracts.IPaginationContract): IPagination {
-        return {
-            skip: paginationContract.skip,
-            count: paginationContract.count,
-            limit: paginationContract.limit,
-            nextPage: paginationContract.next_page,
-            totalCount: paginationContract.total_count ?? null
-        };
-    }
-}

package/lib/utilities/codename.helper.ts

@@ -1,10 +0,0 @@
-export class CodenameHelper {
-    /**
-     * This is used to prevent errors caused by reserved names in content item codename (e.g. 'constructor')
-     */
-    escapeCodenameInCodenameIndexer(codename: string): string {
-        return `_${codename}`;
-    }
-}
-
-export const codenameHelper = new CodenameHelper();

package/lib/utilities/delivery-url.helper.ts

@@ -1,11 +0,0 @@
-export class DeliveryUrlHelper {
-    replaceAssetDomain(originalAssetUrl: string, customDomain: string): string {
-        return `${customDomain}${this.getPathname(originalAssetUrl)}`;
-    }
-
-    getPathname(url: string): string {
-        return new URL(url).pathname;
-    }
-}
-
-export const deliveryUrlHelper = new DeliveryUrlHelper();

package/lib/utilities/enum.helper.ts

@@ -1,38 +0,0 @@
-export class EnumHelper {
-    getAllValues(T: any): string[] {
-        const allEnumValues: string[] = Object.keys(T).map((key) => T[key]);
-        return allEnumValues;
-    }
-
-    getEnumFromValue<T>(T: any, value: string | number): T | undefined {
-        try {
-            if (!value) {
-                return undefined;
-            }
-
-            // we can map back from index number directly
-            if (this.isNumeric(value)) {
-                return <T>T[value];
-            }
-
-            // for strings, we need to compare each value separately
-            const allEnumValues = this.getAllValues(T);
-
-            const result = allEnumValues.find((m) => m.toLowerCase() === value.toString().toLowerCase());
-
-            if (!result) {
-                return undefined;
-            }
-
-            return result as T;
-        } catch (err) {
-            return undefined;
-        }
-    }
-
-    private isNumeric(value: any): boolean {
-        return !isNaN(parseFloat(value)) && isFinite(value);
-    }
-}
-
-export const enumHelper = new EnumHelper();

package/lib/utilities/index.ts

@@ -1,3 +0,0 @@
-export * from './codename.helper';
-export * from './delivery-url.helper';
-export * from './enum.helper';