@kontent-ai/delivery-sdk 12.0.0-0

package/lib/parser/parser.helper.ts

@@ -0,0 +1,103 @@
+import { Elements, ElementType } from '../elements';
+import { IContentItem, ILink, IRichTextImage } from '../models';
+import { IParserElement, IParserElementAttribute } from './parse-models';
+
+export class ParserHelper {
+
+    public readonly sdkResolvedAttributeName: string = 'data-sdk-resolved';
+
+    getLinkedItem(linkedItems: IContentItem[], itemCodename: string): IContentItem | undefined {
+        if (!linkedItems) {
+            return undefined;
+        }
+        return linkedItems.find((m) => m.system.codename === itemCodename);
+    }
+
+    tryGetImage(
+        inputElement: Elements.RichTextElement,
+        linkedItems: IContentItem[],
+        imageId: string
+    ): IRichTextImage | undefined {
+        const elementImage = inputElement.images.find((m) => m.imageId === imageId);
+        if (elementImage) {
+            return elementImage;
+        }
+
+        // try to find image in all linked items
+        if (linkedItems) {
+            for (const linkedItem of linkedItems) {
+                for (const elementKey of Object.keys(linkedItem.elements)) {
+                    const element = linkedItem.elements[elementKey];
+                    if (element.type === ElementType.RichText) {
+                        const richTextElement = element as Elements.RichTextElement;
+                        const richTextElementImage = richTextElement.images.find((m) => m.imageId === imageId);
+                        if (richTextElementImage) {
+                            return richTextElementImage;
+                        }
+                    }
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    tryGetLink(inputElement: Elements.RichTextElement, linkedItems: IContentItem[], linkId: string): ILink | undefined {
+        const elementLink = inputElement.links.find((m) => m.linkId === linkId);
+        if (elementLink) {
+            return elementLink;
+        }
+
+        // try to find link in all linked items
+        if (linkedItems) {
+            for (const linkedItem of linkedItems) {
+                for (const elementKey of Object.keys(linkedItem.elements)) {
+                    const element = linkedItem.elements[elementKey];
+                    if (element.type === ElementType.RichText) {
+                        const richTextElement = element as Elements.RichTextElement;
+                        const richTextElementLink = richTextElement.links.find((m) => m.linkId === linkId);
+                        if (richTextElementLink) {
+                            return richTextElementLink;
+                        }
+                    }
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    convertToParserElement(element: Element): IParserElement {
+        const attributes: IParserElementAttribute[] = [];
+
+        for (let i = 0; i < element.attributes.length; i++) {
+            const attribute = element.attributes[i];
+
+            attributes.push({
+                name: attribute.name,
+                value: attribute.value
+            });
+        }
+
+        return {
+            tag: element.tagName,
+            setAttribute: (attributeName, attributeValue) => {
+                const attribute = element.attributes.getNamedItem(attributeName);
+                if (attribute) {
+                    attribute.value = attributeValue ?? '';
+                } else {
+                    element.setAttribute(attributeName, attributeValue ?? '');
+                }
+            },
+            setInnerHtml: (newHtml) => (element.innerHTML = newHtml),
+            setOuterHtml: (newHtml) => (element.outerHTML = newHtml),
+            html: element.innerHTML,
+            text: element.textContent ? element.textContent : undefined,
+            attributes: attributes,
+            parentElement: element.parentElement ? this.convertToParserElement(element.parentElement) : undefined,
+            sourceElement: element
+        };
+    }
+}
+
+export const parserHelper = new ParserHelper();

package/lib/query/common/base-listing-query.class.ts

@@ -0,0 +1,261 @@
+import { IDeliveryClientConfig } from '../../config';
+import {
+    continuationTokenHeaderName,
+    Filters,
+    IGroupedNetworkResponse,
+    IKontentListAllResponse,
+    IKontentListResponse,
+    IDeliveryNetworkResponse,
+    IListAllQueryConfig,
+    IQueryConfig,
+    Parameters,
+    SortOrder
+} from '../../models';
+import { QueryService } from '../../services';
+import { BaseQuery } from './base-query.class';
+
+export abstract class BaseListingQuery<
+    TResponse extends IKontentListResponse,
+    TAllResponse extends IKontentListAllResponse,
+    TQueryConfig extends IQueryConfig,
+    TContract
+> extends BaseQuery<TResponse, TQueryConfig, TContract> {
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+        super(config, queryService);
+    }
+
+    /**
+     * Empty filter condition
+     * @param element Element with empty value
+     */
+    emptyFilter(element: string): this {
+        this.parameters.push(new Filters.EmptyFilter(element));
+        return this;
+    }
+
+    /**
+     * Not empty filter condition
+     * @param element Element with non-empty value
+     */
+    notEmptyFilter(element: string): this {
+        this.parameters.push(new Filters.NotEmptyFilter(element));
+        return this;
+    }
+
+    /**
+     * Equals filter condition
+     * @param element Element to filter. Example: 'elements.movie'
+     * @param value Value to match. Example: 'Kingsman'
+     */
+    equalsFilter(element: string, value: string): this {
+        this.parameters.push(new Filters.EqualsFilter(element, value));
+        return this;
+    }
+
+    /**
+     * Not equals filter condition
+     * @param element Element to filter. Example: 'elements.movie'
+     * @param value Value to match. Example: 'Kingsman'
+     */
+    notEqualsFilter(element: string, value: string): this {
+        this.parameters.push(new Filters.NotEqualsFilter(element, value));
+        return this;
+    }
+
+    /**
+     * All filter
+     * @param element Element to filter.
+     * @param values Values
+     */
+    allFilter(element: string, values: string[]): this {
+        this.parameters.push(new Filters.AllFilter(element, values));
+        return this;
+    }
+
+    /**
+     * Any filter
+     * @param element Element to filter.
+     * @param values Values
+     */
+    anyFilter(element: string, values: string[]): this {
+        this.parameters.push(new Filters.AnyFilter(element, values));
+        return this;
+    }
+
+    /**
+     * Contains filter
+     * @param element Element to filter.
+     * @param values Values
+     */
+    containsFilter(element: string, values: string[]): this {
+        this.parameters.push(new Filters.ContainsFilter(element, values));
+        return this;
+    }
+
+    /**
+     * Greater then filter
+     * @param element Element to filter.
+     * @param value Value
+     */
+    greaterThanFilter(element: string, value: string): this {
+        this.parameters.push(new Filters.GreaterThanFilter(element, value));
+        return this;
+    }
+
+    /**
+     * Greater then or equals filter
+     * @param element Element to filter.
+     * @param value Value
+     */
+    greaterThanOrEqualFilter(element: string, value: string): this {
+        this.parameters.push(new Filters.GreaterThanOrEqualFilter(element, value));
+        return this;
+    }
+
+    /**
+     * In filter
+     * @param element Element to filter.
+     * @param values Values
+     */
+    inFilter(element: string, values: string[]): this {
+        this.parameters.push(new Filters.InFilter(element, values));
+        return this;
+    }
+
+    /**
+     * Not in filter
+     * @param element Element to filter.
+     * @param values Values
+     */
+    notInFilter(element: string, values: string[]): this {
+        this.parameters.push(new Filters.NotInFilter(element, values));
+        return this;
+    }
+
+    /**
+     * Less then filter
+     * @param element Element to filter.
+     * @param value Value
+     */
+    lessThanFilter(element: string, value: string): this {
+        this.parameters.push(new Filters.LessThanFilter(element, value));
+        return this;
+    }
+
+    /**
+     * @param element Element to filter.
+     * @param value Value
+     */
+    lessThanOrEqualFilter(element: string, value: string): this {
+        this.parameters.push(new Filters.LessThanOrEqualFilter(element, value));
+        return this;
+    }
+
+    /**
+     * @param element Element to filter.
+     * @param lowerValue Lower value of range (e.g. 2)
+     * @param higherValue Higher value of range (e.g. 10)
+     */
+    rangeFilter(element: string, lowerValue: number, higherValue: number): this {
+        this.parameters.push(new Filters.RangeFilter(element, lowerValue, higherValue));
+        return this;
+    }
+
+    /**
+     * Limits the number of items returned by query
+     * @param limit Number of items to load
+     */
+    limitParameter(limit: number): this {
+        this.parameters.push(new Parameters.LimitParameter(limit));
+        return this;
+    }
+
+    /**
+     * Orders query based on given element and sort order
+     * @param element Element by which to order
+     * @param sortOrder Asc/Desc order type
+     */
+    orderParameter(element: string, sortOrder: SortOrder): this {
+        this.parameters.push(new Parameters.OrderParameter(element, sortOrder));
+        return this;
+    }
+
+    /**
+     * Sets descending order on given element
+     * @param element Element by which to order
+     */
+    orderByDescending(element: string): this {
+        this.parameters.push(new Parameters.OrderParameter(element, 'desc'));
+        return this;
+    }
+
+    /**
+     * Sets Ascending order on given element
+     * @param element Element by which to order
+     */
+    orderByAscending(element: string): this {
+        this.parameters.push(new Parameters.OrderParameter(element, 'asc'));
+        return this;
+    }
+
+    /**
+     * Skips the selected number of items
+     * @param skip Number of items to skip
+     */
+    skipParameter(skip: number): this {
+        this.parameters.push(new Parameters.SkipParameter(skip));
+        return this;
+    }
+
+    /**
+     * Sets continuation token header
+     */
+    withContinuationToken(token: string): this {
+        // remove previous continuation token if there is any
+        let queryHeaders = this._queryConfig.customHeaders ?? [];
+        queryHeaders = queryHeaders.filter(m => m.header !== continuationTokenHeaderName);
+
+        this._queryConfig.customHeaders = queryHeaders;
+
+        this.withHeaders([
+            {
+                header: continuationTokenHeaderName,
+                value: token
+            }
+        ]);
+
+        return this;
+    }
+
+    /**
+     * Query to get all items. Uses paging data and may execute multiple HTTP requests depending on number of items
+     */
+    toAllPromise(queryAllConfig?: IListAllQueryConfig<TResponse, TContract>): Promise<IGroupedNetworkResponse<TAllResponse>> {
+        return this.queryService.getListAllResponse<TResponse, TAllResponse, TContract>({
+            page: 1,
+            listQueryConfig: queryAllConfig,
+            allResponseFactory: (items, responses) => {
+                const response = this.allResponseFactory(items, responses);
+                return {
+                    data: response,
+                    responses: responses
+                };
+            },
+            getResponse: (nextPageUrl, continuationToken) => {
+                let query = this;
+
+                if (nextPageUrl) {
+                    query = this.withCustomUrl(nextPageUrl);
+                }
+                if (continuationToken) {
+                    query = this.withContinuationToken(continuationToken);
+                }
+
+                return query.toPromise();
+            }
+        });
+    }
+
+    protected abstract allResponseFactory(items: any[], responses: IDeliveryNetworkResponse<TResponse, TContract>[]): TAllResponse;
+}

package/lib/query/common/base-query.class.ts

@@ -0,0 +1,129 @@
+import { IHeader, IQueryParameter } from '@kontent-ai/core-sdk';
+
+import { IDeliveryClientConfig } from '../../config';
+import { IDeliveryNetworkResponse, IKontentResponse, IQueryConfig, Parameters } from '../../models';
+import { QueryService } from '../../services';
+
+export abstract class BaseQuery<TResponse extends IKontentResponse, TQueryConfig extends IQueryConfig, TContract> {
+    protected parameters: IQueryParameter[] = [];
+    protected customUrl?: string;
+    protected abstract _queryConfig: TQueryConfig;
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {}
+
+    /**
+     * Gets URL of the query
+     */
+    abstract getUrl(): string;
+
+    /**
+     * Gets promise for query execution
+     */
+    abstract toPromise(): Promise<IDeliveryNetworkResponse<TResponse, TContract>>;
+
+    /**
+     * Maps json data to response
+     */
+    abstract map(json: any): TResponse;
+
+    /**
+     * Adds custom parameter to query
+     * @param name Name of parameter
+     * @param value Value of parameter
+     */
+    withCustomParameter(name: string, value: string): this {
+        this.parameters.push(new Parameters.QueryParameter(name, value));
+        return this;
+    }
+
+    /**
+     * Adds parameter to query
+     * @param name Name of parameter
+     * @param value Value of parameter
+     */
+    withParameter(parameter: IQueryParameter): this {
+        this.parameters.push(parameter);
+        return this;
+    }
+
+    /**
+     * Adds parameters to query
+     * @param parameters Array of parameters
+     */
+    withParameters(parameters: IQueryParameter[]): this {
+        this.parameters.push(...parameters);
+        return this;
+    }
+
+    /**
+     * Gets headers used by this query
+     */
+    getHeaders(): IHeader[] {
+        return this.queryService.getHeaders(this._queryConfig, []);
+    }
+
+    /**
+     * Sets request headers
+     */
+    withHeaders(headers: IHeader[]): this {
+        const queryHeaders = this._queryConfig.customHeaders ?? [];
+        queryHeaders.push(...headers);
+        this._queryConfig.customHeaders = queryHeaders;
+        return this;
+    }
+
+    /**
+     * Sets request header
+     */
+    withHeader(header: IHeader): this {
+        const queryHeaders = this._queryConfig.customHeaders ?? [];
+        queryHeaders.push(header);
+        this._queryConfig.customHeaders = queryHeaders;
+        return this;
+    }
+
+    /**
+     * Sets custom URL of request (overrides default URL of the query)
+     */
+    withCustomUrl(url: string): this {
+        this.customUrl = url;
+        return this;
+    }
+
+    /**
+     * Gets all query parameter currently applied to query
+     */
+    getParameters(): IQueryParameter[] {
+        return this.parameters;
+    }
+
+    /**
+     * Used to configure query
+     * @param queryConfig Query configuration
+     */
+    queryConfig(queryConfig: TQueryConfig): this {
+        this._queryConfig = queryConfig;
+        return this;
+    }
+
+    protected resolveUrlInternal(action: string): string {
+        // use custom URL if user specified it
+        if (this.customUrl) {
+            return this.customUrl;
+        }
+
+        // use original url
+        return this.queryService.getUrl(action, this._queryConfig ?? {}, this.getParameters());
+    }
+
+    protected processDefaultLanguageParameter(): void {
+        // add default language if none is specified && default language is specified globally
+        if (this.config.defaultLanguage) {
+            const languageParameter = this.getParameters().find((m) => m.getParam() === 'language');
+            if (!languageParameter) {
+                // language parameter was not specified in query, use globally defined language
+                this.parameters.push(new Parameters.LanguageParameter(this.config.defaultLanguage));
+            }
+        }
+    }
+}

package/lib/query/element/element-query.class.ts

@@ -0,0 +1,50 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { Responses, IElementQueryConfig, IDeliveryNetworkResponse } from '../../models';
+import { QueryService } from '../../services';
+import { BaseQuery } from '../common/base-query.class';
+
+export class ElementQuery extends BaseQuery<
+    Responses.IViewContentTypeElementResponse,
+    IElementQueryConfig,
+    Contracts.IViewContentTypeElementContract
+> {
+
+    protected _queryConfig: IElementQueryConfig = {};
+
+    constructor(
+        protected config: IDeliveryClientConfig,
+        protected queryService: QueryService,
+        private typeCodename: string,
+        private elementCodename: string
+    ) {
+        super(config, queryService);
+
+        if (!typeCodename) {
+            throw Error(`Codename of the type has to be provided`);
+        }
+
+        if (!elementCodename) {
+            throw Error(`Codename of the element has to be provided`);
+        }
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<
+            Responses.IViewContentTypeElementResponse,
+            Contracts.IViewContentTypeElementContract
+        >
+    > {
+        return this.queryService.getElementAsync(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/types/' + this.typeCodename + '/elements/' + this.elementCodename;
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IViewContentTypeElementResponse {
+        return this.queryService.mappingService.viewContentTypeElementResponse(json);
+    }
+}

package/lib/query/index.ts

@@ -0,0 +1,10 @@
+export * from './common/base-query.class';
+export * from './element/element-query.class';
+export * from './item/multiple-items-query.class';
+export * from './item/single-item-query.class';
+export * from './taxonomy/taxonomies-query.class';
+export * from './taxonomy/taxonomy-query.class';
+export * from './type/multiple-type-query.class';
+export * from './type/single-type-query.class';
+export * from './items-feed/items-feed-query.class';
+export * from './language/languages-query.class';

package/lib/query/item/multiple-items-query.class.ts

@@ -0,0 +1,125 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { Filters, IContentItem, IItemQueryConfig, IDeliveryNetworkResponse, Responses, Parameters } from '../../models';
+import { QueryService } from '../../services';
+import { BaseListingQuery } from '../common/base-listing-query.class';
+
+export class MultipleItemsQuery<TContentItem extends IContentItem = IContentItem> extends BaseListingQuery<
+    Responses.IListContentItemsResponse<TContentItem>,
+    Responses.IListContentItemsAllResponse<TContentItem>,
+    IItemQueryConfig,
+    Contracts.IListContentItemsContract
+> {
+    protected _queryConfig: IItemQueryConfig = {};
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+        super(config, queryService);
+    }
+
+    /**
+     * Adds information about the total number of content items matching your query.
+     * When set to true, the pagination object returned in the API response contains
+     * an additional total_count property.
+     */
+    includeTotalCountParameter(): this {
+        this.parameters.push(new Parameters.IncludeTotalCountParameter());
+        return this;
+    }
+
+    /**
+     * Gets only item of given type
+     * @param type Codename of type to get
+     */
+    type(type: string): this {
+        this.parameters.push(new Filters.TypeFilter(type));
+        return this;
+    }
+
+    /**
+     * Gets items of given types (logical or)
+     * I.e. get items of either 'Actor' or 'Movie' type
+     * @param types Types to get
+     */
+    types(types: string[]): this {
+        this.parameters.push(new Filters.TypeFilter(types));
+        return this;
+    }
+
+    /**
+     * Gets only item from given collection
+     * @param collection Codename of collection to get
+     */
+    collection(collection: string): this {
+        this.parameters.push(new Filters.CollectionFilter(collection));
+        return this;
+    }
+
+    /**
+     * Gets items from given collections (logical or)
+     * I.e. get items of either 'default' or 'christmas-campaign' collection
+     * @param collections Collections to get
+     */
+    collections(collections: string[]): this {
+        this.parameters.push(new Filters.CollectionFilter(collections));
+        return this;
+    }
+
+    /**
+     * Indicates depth of query that affects loading of nested linked items.
+     * @param depth Depth of the query (> 0)
+     */
+    depthParameter(depth: number): this {
+        this.parameters.push(new Parameters.DepthParameter(depth));
+        return this;
+    }
+
+    /**
+     * Language codename
+     * @param languageCodename Codename of the language
+     */
+    languageParameter(languageCodename: string): this {
+        this.parameters.push(new Parameters.LanguageParameter(languageCodename));
+        return this;
+    }
+
+    /**
+     * Used to limit the number of elements returned by query.
+     * @param elementCodenames Array of element codenames to fetch
+     */
+    elementsParameter(elementCodenames: string[]): this {
+        this.parameters.push(new Parameters.ElementsParameter(elementCodenames));
+        return this;
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<Responses.IListContentItemsResponse<TContentItem>, Contracts.IListContentItemsContract>
+    > {
+        return this.queryService.getMultipleItems(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/items';
+
+        // add default language is necessry
+        this.processDefaultLanguageParameter();
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IListContentItemsResponse<TContentItem> {
+        return this.queryService.mappingService.listContentItemsResponse(json);
+    }
+
+    protected allResponseFactory(
+        items: any[],
+        responses: IDeliveryNetworkResponse<
+            Responses.IListContentItemsResponse<TContentItem>,
+            Contracts.IListContentItemsContract
+        >[]
+    ): Responses.IListContentItemsAllResponse<TContentItem> {
+        return {
+            items: items,
+            responses: responses
+        };
+    }
+}