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

package/lib/mappers/item.mapper.ts

@@ -1,181 +0,0 @@
-import { codenameHelper } from '../utilities';
-import { IDeliveryClientConfig } from '../config';
-import { Contracts } from '../contracts';
-import {
-    IContentItem,
-    IContentItemsContainer,
-    IContentItemWithRawDataContainer,
-    IContentItemWithRawElements
-} from '../models';
-import { ElementMapper } from './element.mapper';
-
-export interface IMapItemResult<
-    TContentItem extends IContentItem = IContentItem,
-    TLinkedItemType extends IContentItem = IContentItem
-> {
-    item: TContentItem;
-    processedItems: IContentItemsContainer<TLinkedItemType>;
-    preparedItems: IContentItemWithRawDataContainer;
-    processingStartedForCodenames: string[];
-}
-
-export interface IMultipleItemsMapResult<
-    TContentItem extends IContentItem = IContentItem,
-    TLinkedItemType extends IContentItem = IContentItem
-> {
-    items: TContentItem[];
-    linkedItems: IContentItemsContainer<TLinkedItemType>;
-}
-
-export interface ISingleItemMapResult<
-    TContentItem extends IContentItem = IContentItem,
-    TLinkedItemType extends IContentItem = IContentItem
-> {
-    item: TContentItem;
-    linkedItems: IContentItemsContainer<TLinkedItemType>;
-}
-
-export class ItemMapper<TContentItemType extends IContentItem> {
-    private readonly elementMapper: ElementMapper<TContentItemType>;
-
-    constructor(readonly config: IDeliveryClientConfig) {
-        this.elementMapper = new ElementMapper(config);
-    }
-
-    /**
-     * Maps single item to its proper strongly typed model from the given response
-     * @param response Response used to map the item
-     * @param queryConfig Query configuration
-     */
-    mapSingleItemFromResponse<TContentItem extends TContentItemType = TContentItemType>(
-        response: Contracts.IViewContentItemContract
-    ): ISingleItemMapResult<TContentItem, TContentItemType> {
-        const mapResult = this.mapItems<TContentItem>({
-            mainItems: [response.item],
-            linkedItems: Object.values(response.modular_content)
-        });
-
-        return {
-            item: mapResult.items[0],
-            linkedItems: mapResult.linkedItems
-        };
-    }
-
-    /**
-     * Maps multiple items to their strongly typed model from the given  response
-     * @param response Response used to map the item
-     * @param queryConfig Query configuration
-     */
-    mapMultipleItemsFromResponse<TContentItem extends TContentItemType = TContentItemType>(
-        response: Contracts.IItemsWithModularContentContract
-    ): IMultipleItemsMapResult<TContentItem, TContentItemType> {
-        const mapResult = this.mapItems<TContentItem>({
-            mainItems: response.items,
-            linkedItems: Object.values(response.modular_content)
-        });
-
-        return mapResult;
-    }
-
-    /**
-     * Maps item contracts to full models
-     */
-    mapItems<TContentItem extends TContentItemType = TContentItemType>(data: {
-        mainItems: Contracts.IContentItemContract[];
-        linkedItems: Contracts.IContentItemContract[];
-    }): IMultipleItemsMapResult<TContentItem, TContentItemType> {
-        const processedItems: IContentItemsContainer<TContentItem> = {};
-        const preparedItems: IContentItemWithRawDataContainer = {};
-        const processingStartedForCodenames: string[] = [];
-        const mappedMainItems: TContentItem[] = [];
-        const mappedLinkedItems: IContentItemsContainer<TContentItem> = {};
-        const itemsToResolve: Contracts.IContentItemContract[] = [...data.mainItems, ...data.linkedItems];
-
-        // first prepare reference for all items
-        for (const item of itemsToResolve) {
-            preparedItems[codenameHelper.escapeCodenameInCodenameIndexer(item.system.codename)] = {
-                item: this.createContentItem(item),
-                rawItem: item
-            };
-        }
-
-        // then resolve main items
-        for (const item of data.mainItems) {
-            const itemResult = this.mapItem<TContentItem>({
-                item: preparedItems[codenameHelper.escapeCodenameInCodenameIndexer(item.system.codename)],
-                processedItems: processedItems,
-                preparedItems: preparedItems,
-                processingStartedForCodenames: processingStartedForCodenames
-            });
-            mappedMainItems.push(itemResult.item);
-        }
-
-        // and linked items
-        for (const item of data.linkedItems) {
-            const itemResult = this.mapItem<TContentItem>({
-                item: preparedItems[codenameHelper.escapeCodenameInCodenameIndexer(item.system.codename)],
-                processedItems: processedItems,
-                preparedItems: preparedItems,
-                processingStartedForCodenames: processingStartedForCodenames
-            });
-
-            mappedLinkedItems[item.system.codename] = itemResult.item;
-        }
-
-        return {
-            items: mappedMainItems,
-            linkedItems: mappedLinkedItems
-        };
-    }
-
-    /**
-     * Maps item contract to full model
-     */
-    private mapItem<TContentItem extends TContentItemType = TContentItemType>(data: {
-        item: IContentItemWithRawElements;
-        processedItems: IContentItemsContainer<TContentItem>;
-        processingStartedForCodenames: string[];
-        preparedItems: IContentItemWithRawDataContainer;
-    }): IMapItemResult<TContentItem, TContentItemType> {
-        if (!data.item) {
-            throw Error(`Could not map item because its undefined`);
-        }
-
-        const result = this.elementMapper.mapElements<TContentItem>({
-            dataToMap: data.item,
-            preparedItems: data.preparedItems,
-            processingStartedForCodenames: [],
-            processedItems: data.processedItems
-        });
-
-        if (!result) {
-            throw Error(`Mapping of content item '${data.item.item.system.codename}' failed`);
-        }
-        return {
-            item: result.item,
-            processedItems: result.processedItems,
-            preparedItems: result.preparedItems,
-            processingStartedForCodenames: result.processingStartedForCodenames
-        };
-    }
-
-    private createContentItem(item: Contracts.IContentItemContract): IContentItem {
-        const contentItem: IContentItem = {
-            elements: {},
-            system: {
-                codename: item.system.codename,
-                collection: item.system.collection,
-                id: item.system.id,
-                language: item.system.language,
-                lastModified: item.system.last_modified,
-                name: item.system.name,
-                sitemapLocations: item.system.sitemap_locations,
-                type: item.system.type,
-                workflowStep: item.system.workflow_step ?? null,
-                workflow: item.system.workflow ?? null
-            }
-        };
-
-        return contentItem;
-    }
-}

package/lib/mappers/language.mapper.ts

@@ -1,24 +0,0 @@
-import { Contracts } from '../contracts';
-import { ILanguage } from '../models';
-
-export class LanguageMapper<TLanguageCodenames extends string> {
-    mapMultipleLanguages(response: Contracts.IListLanguagesContract): ILanguage<TLanguageCodenames>[] {
-        return response.languages.map((language) => {
-            return this.mapLanguage(language);
-        });
-    }
-
-    private mapLanguage(language: Contracts.ILanguageContract): ILanguage<TLanguageCodenames> {
-        if (!language) {
-            throw Error(`Cannot map language`);
-        }
-
-        return {
-            system: {
-                codename: language.system.codename as TLanguageCodenames,
-                id: language.system.id,
-                name: language.system.name
-            }
-        };
-    }
-}

package/lib/mappers/sync.mapper.ts

@@ -1,32 +0,0 @@
-import { Contracts } from '../contracts';
-import { IContentItemDelta } from '../models';
-
-export class SyncMapper {
-    mapContentItemDelta(itemDeltaContract: Contracts.IContentItemDeltaContract): IContentItemDelta {
-        const systemContract = itemDeltaContract.data.system;
-
-        const elements: Contracts.IContentItemElementsContracts = itemDeltaContract.data.elements
-            ? itemDeltaContract.data.elements
-            : {};
-
-        return {
-            changeType: itemDeltaContract.change_type,
-            timestamp: itemDeltaContract.timestamp,
-            data: {
-                elements: elements,
-                system: {
-                    codename: systemContract.codename,
-                    collection: systemContract.collection,
-                    id: systemContract.id,
-                    language: systemContract.language,
-                    lastModified: systemContract.last_modified,
-                    name: systemContract.name,
-                    sitemapLocations: systemContract.sitemap_locations,
-                    type: systemContract.type,
-                    workflowStep: systemContract.workflow_step ?? null,
-                    workflow: systemContract.workflow ?? null
-                }
-            }
-        };
-    }
-}

package/lib/mappers/taxonomy.mapper.ts

@@ -1,77 +0,0 @@
-import { Contracts } from '../contracts';
-import { ITaxonomyGroup, ITaxonomySystemAttributes, ITaxonomyTerms } from '../models';
-
-export class TaxonomyMapper<TaxonomyCodenames extends string> {
-    mapTaxonomy(
-        taxonomySystem: Contracts.ITaxonomySystemAttributesContract,
-        taxonomyTerms: Contracts.ITaxonomyTermsContract[]
-    ): ITaxonomyGroup<TaxonomyCodenames> {
-        if (!taxonomySystem) {
-            throw Error(`Cannot map taxonomy due to missing 'system' property`);
-        }
-
-        if (!taxonomyTerms) {
-            throw Error(`Cannot map taxonomy due to missing 'terms' property`);
-        }
-
-        if (!Array.isArray(taxonomyTerms)) {
-            throw Error(`Cannot map terms because no terms array was provided`);
-        }
-
-        const mappedSystemAttributes: ITaxonomySystemAttributes<TaxonomyCodenames> = {
-            name: taxonomySystem.name,
-            codename: taxonomySystem.codename as TaxonomyCodenames,
-            id: taxonomySystem.id,
-            lastModified: taxonomySystem.last_modified
-        };
-
-        const mappedTerms: ITaxonomyTerms[] = this.mapTaxonomyTerms(taxonomyTerms);
-
-        return {
-            system: mappedSystemAttributes,
-            terms: mappedTerms
-        };
-    }
-
-    mapTaxonomies(taxonomies: Contracts.ITaxonomyGroupContract[]): ITaxonomyGroup<TaxonomyCodenames>[] {
-        if (!taxonomies) {
-            throw Error(`Cannot map taxonomy due to missing 'taxonomies' property`);
-        }
-
-        if (!Array.isArray(taxonomies)) {
-            throw Error(`Cannot map taxonomies because the 'taxonomies' property is not an array `);
-        }
-
-        const mappedTaxonomies: ITaxonomyGroup<TaxonomyCodenames>[] = [];
-
-        taxonomies.forEach((taxonomy) => {
-            mappedTaxonomies.push(this.mapTaxonomy(taxonomy.system, taxonomy.terms));
-        });
-
-        return mappedTaxonomies;
-    }
-
-    /**
-     * Recursively map array of taxonomy terms
-     * @param termsArray Terms array to map
-     */
-    private mapTaxonomyTerms(termsArray: Contracts.ITaxonomyTermsContract[]): ITaxonomyTerms[] {
-        if (termsArray.length === 0) {
-            return [];
-        }
-
-        const mappedTermsArray: ITaxonomyTerms[] = [];
-
-        termsArray.forEach((terms) => {
-            const mappedTerms: ITaxonomyTerms = {
-                codename: terms.codename,
-                name: terms.name,
-                terms: this.mapTaxonomyTerms(terms.terms)
-            };
-
-            mappedTermsArray.push(mappedTerms);
-        });
-
-        return mappedTermsArray;
-    }
-}

package/lib/mappers/type.mapper.ts

@@ -1,76 +0,0 @@
-import { Contracts } from '../contracts';
-import { IContentType, IContentTypeSystemAttributes, IGenericElement } from '../models';
-
-export class TypeMapper<TContentTypeCodenames extends string> {
-    mapSingleType(response: Contracts.IViewContentTypeContract): IContentType<TContentTypeCodenames> {
-        return this.mapType(response);
-    }
-
-    mapMultipleTypes(response: Contracts.IListContentTypeContract): IContentType<TContentTypeCodenames>[] {
-        return response.types.map((type) => {
-            return this.mapType(type);
-        });
-    }
-
-    private mapType(type: Contracts.IContentTypeContract): IContentType<TContentTypeCodenames> {
-        if (!type) {
-            throw Error(`Cannot map type`);
-        }
-
-        if (!type.elements) {
-            throw Error(`Cannot map type elements`);
-        }
-
-        const system: IContentTypeSystemAttributes<TContentTypeCodenames> = {
-            codename: type.system.codename as TContentTypeCodenames,
-            id: type.system.id,
-            name: type.system.name,
-            lastModified: type.system.last_modified
-        };
-
-        const elements: IGenericElement[] = [];
-
-        const elementNames = Object.getOwnPropertyNames(type.elements);
-        elementNames.forEach((elementName: string) => {
-            const typeElement = type.elements[elementName];
-
-            if (!typeElement) {
-                throw Error(`Cannot find element '${elementName}' on type '${type.system.codename}'`);
-            }
-
-            // use json property as a codename of the type element
-            const elementCodename = elementName;
-
-            // extra properties for certain element types
-            const options: Contracts.IElementOptionContract[] = [];
-
-            // some elements can contain options
-            const rawOptions = typeElement.options;
-            if (rawOptions) {
-                if (!Array.isArray(rawOptions)) {
-                    throw Error(`Content type 'options' property has to be an array`);
-                }
-
-                rawOptions.forEach((rawOption) => {
-                    options.push({
-                        codename: rawOption.codename,
-                        name: rawOption.name
-                    });
-                });
-            }
-
-            elements.push({
-                codename: elementCodename,
-                taxonomyGroup: typeElement.taxonomy_group,
-                options: options,
-                name: typeElement.name,
-                type: typeElement.type
-            });
-        });
-
-        return {
-            elements: elements,
-            system: system
-        };
-    }
-}

package/lib/mappers/used-in.mapper.ts

@@ -1,20 +0,0 @@
-import { Contracts } from '../contracts';
-import { ClientTypes, IUsedInItemRecord } from '../models';
-
-export class UsedInMapper<TClientTypes extends ClientTypes> {
-    mapUsedInItem(response: Contracts.IUsedInItemContract): IUsedInItemRecord<TClientTypes> {
-        return {
-            system: {
-                id: response.system.id,
-                name: response.system.name,
-                codename: response.system.codename,
-                language: response.system.language,
-                type: response.system.type,
-                collection: response.system.collection,
-                workflow: response.system.workflow,
-                workflowStep: response.system.workflow_step,
-                lastModified: response.system.last_modified
-            }
-        };
-    }
-}

package/lib/models/common/base-responses.ts

@@ -1,13 +0,0 @@
-import { IResponse } from '@kontent-ai/core-sdk';
-
-export interface IDeliveryNetworkResponse<TData, TContract> {
-    data: TData;
-    response: IResponse<TContract>;
-    xContinuationToken?: string;
-    hasStaleContent: boolean;
-}
-
-export interface IGroupedNetworkResponse<TData> {
-    data: TData;
-    responses: IDeliveryNetworkResponse<any, any>[];
-}

package/lib/models/common/common-models.ts

@@ -1,118 +0,0 @@
-import { IHeader, IHttpCancelRequestToken, IQueryParameter } from '@kontent-ai/core-sdk';
-import { IDeliveryNetworkResponse } from './base-responses';
-import { IPagination } from './pagination.class';
-
-export type LinkedItemsReferenceHandler = 'map' | 'ignore';
-
-export interface IProxyUrlData {
-    action: string;
-    domain: string;
-    queryParameters: IQueryParameter[];
-    queryString: string;
-    queryConfig: IQueryConfig;
-    environmentId: string;
-}
-
-export interface ISDKInfo {
-    /**
-     * Name of SDK
-     */
-    name: string;
-    /**
-     * Version SDK
-     */
-    version: string;
-    /**
-     * Host of SDK
-     */
-    host: string;
-}
-
-export interface IKontentResponse {}
-
-export interface IKontentListWithHeaderResponse extends IKontentResponse {
-    items: any[];
-}
-
-export interface IKontentListResponse extends IKontentResponse {
-    pagination?: IPagination;
-    items: any[];
-}
-
-export interface IKontentListAllResponse extends IKontentResponse {
-    responses: any[];
-    items: any[];
-}
-
-export interface IListAllQueryConfig<TResponse extends IKontentListResponse, TContract> {
-    /**
-     * Number of pages to get. If not set, all available pages are fetched.
-     */
-    pages?: number;
-
-    /**
-     * Delay between each HTTP requests
-     */
-    delayBetweenRequests?: number;
-
-    /**
-     * Executed when a list response is loaded
-     */
-    responseFetched?: (
-        response: IDeliveryNetworkResponse<TResponse, TContract>,
-        nextPageUrl?: string,
-        continuationToken?: string
-    ) => void;
-}
-
-export interface IQueryConfig {
-    /**
-     * Indicates if query should use preview mode. Overrides default configuration
-     */
-    usePreviewMode?: boolean;
-
-    /**
-     * Indicates if query should use secured delivery API mode.  Overrides default configuration
-     */
-    useSecuredMode?: boolean;
-
-    /**
-     * If the requested content has changed since the last request, the header determines whether
-     * to wait while fetching content. This can be useful when retrieving changed content
-     * in reaction to a webhook call. By default, when the header is not set, the API
-     * serves old content (if cached by the CDN) while it's fetching the new content
-     * to minimize wait time.
-     */
-    waitForLoadingNewContent?: boolean;
-
-    /**
-     * Extra headers added to request
-     */
-    customHeaders?: IHeader[];
-
-    /**
-     * Cancel token
-     */
-    cancelToken?: IHttpCancelRequestToken<any>;
-}
-
-export interface IDeliveryErrorRaw {
-    message: string;
-    request_id: string | null;
-    error_code: number;
-    specific_code: number;
-}
-
-export class DeliveryError {
-    public message: string;
-    public requestId: string | null;
-    public errorCode: number;
-    public specificCode: number;
-
-    constructor(data: { message: string; requestId: string | null; errorCode: number; specificCode: number }) {
-        this.message = data.message;
-        this.requestId = data.requestId;
-        this.errorCode = data.errorCode;
-        this.specificCode = data.specificCode;
-    }
-}