@kontent-ai/delivery-sdk 12.0.0-0

package/lib/query/item/single-item-query.class.ts

@@ -0,0 +1,80 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { IContentItem, IItemQueryConfig, IDeliveryNetworkResponse, Responses, Parameters } from '../../models';
+import { QueryService } from '../../services';
+import { BaseQuery } from '../common/base-query.class';
+
+export class SingleItemQuery<TContentItem extends IContentItem = IContentItem> extends BaseQuery<
+    Responses.IViewContentItemResponse<TContentItem>,
+    IItemQueryConfig,
+    Contracts.IViewContentItemContract
+> {
+    protected _queryConfig: IItemQueryConfig = {};
+
+    constructor(
+        protected config: IDeliveryClientConfig,
+        protected queryService: QueryService,
+        private codename: string
+    ) {
+        super(config, queryService);
+
+        if (!codename) {
+            throw Error(`'codename' has to be configured for 'SingleItemQuery' query`);
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Used to configure query
+     * @param queryConfig Query configuration
+     */
+    queryConfig(queryConfig: IItemQueryConfig): this {
+        this._queryConfig = queryConfig;
+        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.IViewContentItemResponse<TContentItem>, Contracts.IViewContentItemContract>
+    > {
+        return this.queryService.getSingleItemAsync(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/items/' + this.codename;
+
+        // add default language is necessry
+        this.processDefaultLanguageParameter();
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IViewContentItemResponse<TContentItem> {
+        return this.queryService.mappingService.viewContentItemResponse(json);
+    }
+}

package/lib/query/items-feed/items-feed-query.class.ts

@@ -0,0 +1,113 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { Filters, IContentItem, IItemQueryConfig, IDeliveryNetworkResponse, Parameters, Responses } from '../../models';
+import { QueryService } from '../../services';
+import { BaseListingQuery } from '../common/base-listing-query.class';
+
+export class ItemsFeedQuery<TContentItem extends IContentItem = IContentItem> extends BaseListingQuery<
+    Responses.IListItemsFeedResponse<TContentItem>,
+    Responses.IListItemsFeedAllResponse<TContentItem>,
+    IItemQueryConfig,
+    Contracts.IItemsFeedContract
+> {
+
+    protected _queryConfig: IItemQueryConfig = {};
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+        super(config, queryService);
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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.IListItemsFeedResponse<TContentItem>, Contracts.IItemsFeedContract>
+    > {
+        return this.queryService.getItemsFeed(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/items-feed';
+
+        // add default language is necessry
+        this.processDefaultLanguageParameter();
+
+        return super.resolveUrlInternal(action);
+    }
+
+    /**
+     * Used to configure query
+     * @param queryConfig Query configuration
+     */
+    queryConfig(queryConfig: IItemQueryConfig): this {
+        this._queryConfig = queryConfig;
+        return this;
+    }
+
+    map(json: any): Responses.IListItemsFeedResponse<TContentItem> {
+        return this.queryService.mappingService.itemsFeedResponse(json);
+    }
+
+    protected allResponseFactory(
+        items: any[],
+        responses: IDeliveryNetworkResponse<Responses.IListItemsFeedResponse<TContentItem>, Contracts.IItemsFeedContract>[]
+    ): Responses.IListItemsFeedAllResponse<TContentItem> {
+        return {
+            items: items,
+            responses: responses
+        };
+    }
+}

package/lib/query/language/languages-query.class.ts

@@ -0,0 +1,96 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import {
+    continuationTokenHeaderName,
+    IDeliveryNetworkResponse,
+    ILanguagesQueryConfig,
+    Parameters,
+    Responses
+} from '../../models';
+import { QueryService } from '../../services';
+import { BaseListingQuery } from '../common/base-listing-query.class';
+
+export class LanguagesQuery extends BaseListingQuery<
+    Responses.IListLanguagesResponse,
+    Responses.IListLanguagesAllResponse,
+    ILanguagesQueryConfig,
+    Contracts.IListLanguagesContract
+> {
+    /**
+     * Endpoint
+     */
+    protected readonly endpoint: string = 'languages';
+
+    protected _queryConfig: ILanguagesQueryConfig = {};
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+        super(config, queryService);
+    }
+
+    /**
+     * Limits the number of taxonomies returned by query
+     * @param limit Number of taxonomies to load
+     */
+    limitParameter(limit: number): this {
+        this.parameters.push(new Parameters.LimitParameter(limit));
+        return this;
+    }
+
+    /**
+     * Skips the selected number of taxonomies
+     * @param skip Number of taxonomies to skip
+     */
+    skipParameter(skip: number): this {
+        this.parameters.push(new Parameters.SkipParameter(skip));
+        return this;
+    }
+
+    /**
+     * Sets continuation token header
+     */
+    withContinuationToken(token: string): this {
+        this.withHeaders([
+            {
+                header: continuationTokenHeaderName,
+                value: token
+            }
+        ]);
+
+        return this;
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<Responses.IListLanguagesResponse, Contracts.IListLanguagesContract>
+    > {
+        return this.queryService.getLanguages(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/' + this.endpoint;
+
+        return super.resolveUrlInternal(action);
+    }
+
+    /**
+     * Used to configure query
+     * @param queryConfig Query configuration
+     */
+    queryConfig(queryConfig: ILanguagesQueryConfig): this {
+        this._queryConfig = queryConfig;
+        return this;
+    }
+
+    map(json: any): Responses.IListLanguagesResponse {
+        return this.queryService.mappingService.listLanguagesResponse(json);
+    }
+
+    protected allResponseFactory(
+        items: any[],
+        responses: IDeliveryNetworkResponse<Responses.IListLanguagesResponse, Contracts.IListLanguagesContract>[]
+    ): Responses.IListLanguagesAllResponse {
+        return {
+            items: items,
+            responses: responses
+        };
+    }
+}

package/lib/query/taxonomy/taxonomies-query.class.ts

@@ -0,0 +1,93 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import {
+    continuationTokenHeaderName,
+    IDeliveryNetworkResponse,
+    ITaxonomyQueryConfig,
+    Parameters,
+    Responses
+} from '../../models';
+import { QueryService } from '../../services';
+import { BaseListingQuery } from '../common/base-listing-query.class';
+
+export class TaxonomiesQuery extends BaseListingQuery<
+    Responses.IListTaxonomiesResponse,
+    Responses.IListTaxonomiesAllResponse,
+    ITaxonomyQueryConfig,
+    Contracts.IListTaxonomyGroupsContract
+> {
+    /**
+     * Taxonomies endpoint URL action
+     */
+    protected readonly taxonomiesEndpoint: string = 'taxonomies';
+
+    protected _queryConfig: ITaxonomyQueryConfig = {};
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+        super(config, queryService);
+    }
+
+    /**
+     * Limits the number of taxonomies returned by query
+     * @param limit Number of taxonomies to load
+     */
+    limitParameter(limit: number): this {
+        this.parameters.push(new Parameters.LimitParameter(limit));
+        return this;
+    }
+
+    /**
+     * Skips the selected number of taxonomies
+     * @param skip Number of taxonomies to skip
+     */
+    skipParameter(skip: number): this {
+        this.parameters.push(new Parameters.SkipParameter(skip));
+        return this;
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<
+            Responses.IListTaxonomiesResponse,
+            Contracts.IListTaxonomyGroupsContract
+        >
+    > {
+        return this.queryService.getTaxonomies(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    /**
+     * Sets continuation token header
+     */
+    withContinuationToken(token: string): this {
+        this.withHeaders([
+            {
+                header: continuationTokenHeaderName,
+                value: token
+            }
+        ]);
+
+        return this;
+    }
+
+    getUrl(): string {
+        const action = '/' + this.taxonomiesEndpoint;
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IListTaxonomiesResponse {
+        return this.queryService.mappingService.listTaxonomiesResponse(json);
+    }
+
+    protected allResponseFactory(
+        items: any[],
+        responses: IDeliveryNetworkResponse<
+            Responses.IListTaxonomiesResponse,
+            Contracts.IListTaxonomyGroupsContract
+        >[]
+    ): Responses.IListTaxonomiesAllResponse {
+        return {
+            items: items,
+            responses: responses
+        };
+    }
+}

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

@@ -0,0 +1,46 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { IDeliveryNetworkResponse, ITaxonomyQueryConfig, Responses } from '../../models';
+import { QueryService } from '../../services';
+import { BaseQuery } from '../common/base-query.class';
+
+export class TaxonomyQuery extends BaseQuery<
+    Responses.IViewTaxonomyResponse,
+    ITaxonomyQueryConfig,
+    Contracts.IViewTaxonomyGroupContract
+> {
+    /**
+     * Taxonomies endpoint URL action
+     */
+    protected readonly taxonomiesEndpoint: string = 'taxonomies';
+
+    protected _queryConfig: ITaxonomyQueryConfig = {};
+
+    constructor(
+        protected config: IDeliveryClientConfig,
+        protected queryService: QueryService,
+        private taxonomyCodename: string
+    ) {
+        super(config, queryService);
+
+        if (!taxonomyCodename) {
+            throw Error(`Cannot create taxonomy query without codename of the taxonomy`);
+        }
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<Responses.IViewTaxonomyResponse, Contracts.IViewTaxonomyGroupContract>
+    > {
+        return this.queryService.getTaxonomy(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/' + this.taxonomiesEndpoint + '/' + this.taxonomyCodename;
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IViewTaxonomyResponse {
+        return this.queryService.mappingService.viewTaxonomyResponse(json);
+    }
+}

package/lib/query/type/multiple-type-query.class.ts

@@ -0,0 +1,48 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { IContentTypeQueryConfig, IDeliveryNetworkResponse, Responses } from '../../models';
+import { QueryService } from '../../services';
+import { BaseListingQuery } from '../common/base-listing-query.class';
+
+export class MultipleTypeQuery extends BaseListingQuery<
+    Responses.IListContentTypesResponse,
+    Responses.IListContentTypesAllResponse,
+    IContentTypeQueryConfig,
+    Contracts.IListContentTypeContract
+> {
+
+    protected _queryConfig: IContentTypeQueryConfig = {};
+
+    constructor(protected config: IDeliveryClientConfig, protected queryService: QueryService) {
+        super(config, queryService);
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<Responses.IListContentTypesResponse, Contracts.IListContentTypeContract>
+    > {
+        return this.queryService.getMultipleTypes(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/types';
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IListContentTypesResponse {
+        return this.queryService.mappingService.listContentTypesResponse(json);
+    }
+
+    protected allResponseFactory(
+        items: any[],
+        responses: IDeliveryNetworkResponse<
+            Responses.IListContentTypesResponse,
+            Contracts.IListContentTypeContract
+        >[]
+    ): Responses.IListContentTypesAllResponse {
+        return {
+            items: items,
+            responses: responses
+        };
+    }
+}

package/lib/query/type/single-type-query.class.ts

@@ -0,0 +1,41 @@
+import { Contracts } from '../../contracts';
+import { IDeliveryClientConfig } from '../../config';
+import { IContentTypeQueryConfig, IDeliveryNetworkResponse, Responses } from '../../models';
+import { QueryService } from '../../services';
+import { BaseQuery } from '../common/base-query.class';
+
+export class SingleTypeQuery extends BaseQuery<
+    Responses.IViewContentTypeResponse,
+    IContentTypeQueryConfig,
+    Contracts.IViewContentTypeContract
+> {
+    protected _queryConfig: IContentTypeQueryConfig = {};
+
+    constructor(
+        protected config: IDeliveryClientConfig,
+        protected queryService: QueryService,
+        private typeCodename: string
+    ) {
+        super(config, queryService);
+
+        if (!typeCodename) {
+            throw Error(`Cannot create type query without the codename of the type`);
+        }
+    }
+
+    toPromise(): Promise<
+        IDeliveryNetworkResponse<Responses.IViewContentTypeResponse, Contracts.IViewContentTypeContract>
+    > {
+        return this.queryService.getSingleType(this.getUrl(), this._queryConfig ?? {});
+    }
+
+    getUrl(): string {
+        const action = '/types/' + this.typeCodename;
+
+        return super.resolveUrlInternal(action);
+    }
+
+    map(json: any): Responses.IViewContentTypeResponse {
+        return this.queryService.mappingService.viewContentTypeResponse(json);
+    }
+}

package/lib/resolvers/index.ts

@@ -0,0 +1,10 @@
+export * from './rich-text/rich-text-resolver.models';
+export * from './property-name/camel-case-property-name-resolver.class';
+export * from './property-name/pascal-case-property-name-resolver.class';
+export * from './property-name/snake-case-property-name-resolver.class';
+export * from './rich-text/sync/rich-text-html-resolver';
+export * from './rich-text/sync/rich-text-object-resolver';
+export * from './rich-text/sync/rich-text-json-resolver';
+export * from './rich-text/async/async-rich-text-html-resolver';
+
+

package/lib/resolvers/property-name/camel-case-property-name-resolver.class.ts

@@ -0,0 +1,11 @@
+import { textHelper } from '../../utilities';
+import { PropertyNameResolver } from '../../models';
+
+export const camelCasePropertyNameResolver: PropertyNameResolver = (contentType, element) => {
+    return textHelper.addUnderscoreWhenStarsWithNumber(textHelper.removeZeroWidthCharacters(camelize(element)));
+};
+
+function camelize(str: string): string {
+    str = str.replace(textHelper.getPropertyNameRegex(), (_, c) => (c ? c.toUpperCase() : ''));
+    return str.substring(0, 1).toLowerCase() + str.substring(1);
+}

package/lib/resolvers/property-name/pascal-case-property-name-resolver.class.ts

@@ -0,0 +1,11 @@
+import { textHelper } from '../../utilities';
+import { PropertyNameResolver } from '../../models';
+
+export const pascalCasePropertyNameResolver: PropertyNameResolver = (contentType, element) => {
+    return textHelper.addUnderscoreWhenStarsWithNumber(textHelper.removeZeroWidthCharacters(camelize(element)));
+};
+
+function camelize(str: string): string {
+    str = str.replace(textHelper.getPropertyNameRegex(), (_, c) => (c ? c.toUpperCase() : ''));
+    return str.substring(0, 1).toUpperCase() + str.substring(1);
+}

package/lib/resolvers/property-name/snake-case-property-name-resolver.class.ts

@@ -0,0 +1,29 @@
+import { textHelper } from '../../utilities';
+import { PropertyNameResolver } from '../../models';
+
+export const snakeCasePropertyNameResolver: PropertyNameResolver = (contentType, element) => {
+    return textHelper
+        .addUnderscoreWhenStarsWithNumber(textHelper.removeZeroWidthCharacters(toSnakeCase(element)))
+        .toLowerCase();
+};
+
+function toSnakeCase(str: string): string {
+    str = str.replace(textHelper.getPropertyNameRegex(), (_, c) => '_' + (c ? c.toLowerCase() : ''));
+    return removeEndUnderscore(removeStartUnderscore(str));
+}
+
+function removeStartUnderscore(str: string): string {
+    if (!str.startsWith('_')) {
+        return str;
+    }
+
+    return str.substring(1);
+}
+
+function removeEndUnderscore(str: string): string {
+    if (!str.endsWith('_')) {
+        return str;
+    }
+
+    return str.slice(0, -1);
+}

package/lib/resolvers/rich-text/async/async-rich-text-html-resolver.ts

@@ -0,0 +1,92 @@
+import { IResolvedRichTextHtmlResult, IAsyncRichTextHtmlResolverInput } from '../rich-text-resolver.models';
+import { asyncBrowserParser, IAsyncParser, parserConfiguration, parserHelper } from '../../../parser';
+import { BaseAsyncRichTextResolver } from '../base/base-async-rich-text-resolver';
+
+export class AsyncRichTextHtmlResolver extends BaseAsyncRichTextResolver<
+    IAsyncRichTextHtmlResolverInput,
+    IResolvedRichTextHtmlResult
+> {
+    constructor(parser?: IAsyncParser<string>) {
+        super(asyncBrowserParser, parser);
+    }
+
+    async resolveRichTextAsync(input: IAsyncRichTextHtmlResolverInput): Promise<IResolvedRichTextHtmlResult> {
+        return await this.resolveRichTextInternalAsync(input.element.value, input);
+    }
+
+    private async resolveRichTextInternalAsync(
+        html: string,
+        input: IAsyncRichTextHtmlResolverInput
+    ): Promise<IResolvedRichTextHtmlResult> {
+        const parsedResult = await super.getAsyncParser().parseAsync(
+            html,
+            input.element,
+            {
+                elementResolverAsync: async (element) => {},
+                contentItemResolverAsync: async (element, itemCodename, linkedItemIndex, linkedItem) => {
+                    const parentElement = element.parentElement;
+
+                    if (parentElement) {
+                        const resolvedItemHtml = input.contentItemResolverAsync
+                            ? (await input.contentItemResolverAsync(itemCodename, linkedItem)).contentItemHtml ?? ''
+                            : '';
+
+                        // resursively resolve HTML
+                        const innerHtml = (await this.resolveRichTextInternalAsync(resolvedItemHtml, input)).html;
+
+                        // set resolved html
+                        if (input.preserveResolvedObjectTags === true) {
+                            element.setInnerHtml(innerHtml);
+                        } else {
+                            element.setOuterHtml(innerHtml);
+                        }
+
+                        // set resolved attribute
+                        element.setAttribute(parserHelper.sdkResolvedAttributeName, '1');
+                    }
+                },
+                genericElementResolverAsync: async (element) => {
+                    // do nothing to generic elements
+                },
+                imageResolverAsync: async (element, imageId, image) => {
+                    // get image result
+                    const imageResult = input.imageResolverAsync
+                        ? await input.imageResolverAsync(imageId, image)
+                        : undefined;
+
+                    // html has priority over url resolver
+                    if (imageResult?.imageHtml) {
+                        // replace link html
+                        element.setOuterHtml(imageResult.imageHtml);
+                    } else if (imageResult?.imageUrl) {
+                        // set link url only
+                        element.setAttribute(parserConfiguration.imageElementData.srcAttribute, imageResult.imageUrl);
+                    }
+                },
+                urlResolverAsync: async (element, linkId, linkText, link) => {
+                    if (input.urlResolverAsync) {
+                        const urlResult = await input.urlResolverAsync(linkId, linkText, link);
+
+                        // html has priority over url resolver
+                        if (urlResult?.linkHtml) {
+                            // replace link html
+                            element.setOuterHtml(urlResult.linkHtml);
+                        } else if (urlResult?.linkUrl) {
+                            // set link url only
+                            element.setAttribute('href', urlResult.linkUrl);
+                        }
+                    }
+                }
+            },
+            input.linkedItems ?? []
+        );
+
+        return {
+            componentCodenames: parsedResult.componentCodenames,
+            linkedItemCodenames: parsedResult.linkedItemCodenames,
+            html: parsedResult.result
+        };
+    }
+}
+
+export const createAsyncRichTextHtmlResolver = (parser?: IAsyncParser<string>) => new AsyncRichTextHtmlResolver(parser);