@kontent-ai/delivery-sdk 12.0.0-0

package/lib/models/common/parameters.ts

@@ -0,0 +1,166 @@
+import { IQueryParameter } from '@kontent-ai/core-sdk';
+
+import { SortOrder } from './sort-order';
+
+export namespace Parameters {
+    const defaultValue: string = '';
+
+    export class QueryParameter implements IQueryParameter {
+        /**
+         * Parameter
+         * @constructor
+         * @param {string} name - Name of the parameter
+         * @param {string} value - Value of the parameter
+         */
+        constructor(public name: string, public value: string) {
+            if (!name) {
+                throw Error(`Name of the parameter is not specified`);
+            }
+        }
+
+        getParam(): string {
+            return `${this.name}=${this.value}`;
+        }
+    }
+
+    export class ElementsParameter implements IQueryParameter {
+        /**
+         * Sets elements (projection) so that only certain elements from a content item are returned
+         * @constructor
+         * @param {string[]} elementCodenames - Array of element codenames to include in response.
+         */
+        constructor(public elementCodenames: string[]) {}
+
+        getParam(): string {
+            return `elements=${this.getParamValue()}`;
+        }
+
+        private getParamValue(): string | undefined {
+            if (!this.elementCodenames) {
+                return defaultValue;
+            }
+
+            return this.elementCodenames
+                .map((m) => {
+                    if (!m) {
+                        throw Error(`Codename of 'ElementsParameter' cannot be null or empty`);
+                    }
+                    return m.trim();
+                })
+                .join(',');
+        }
+    }
+
+    export class LimitParameter implements IQueryParameter {
+        /**
+         * Limits the number of items that are returned from response
+         * @constructor
+         * @param {number} limit - Number of elements that will be returned
+         */
+        constructor(public limit: number) {
+            if (limit <= 0) {
+                throw Error(`'LimitParameter' must specify a positive integer`);
+            }
+        }
+
+        getParam(): string {
+            return `limit=${this.limit}`;
+        }
+
+    }
+
+    export class IncludeTotalCountParameter implements IQueryParameter {
+        /**
+         * Adds 'includeTotalCount' query parameter to query
+         * @constructor
+         */
+        constructor() {}
+
+        getParam(): string {
+            return `includeTotalCount=true`;
+        }
+    }
+
+    export class SkipParameter implements IQueryParameter {
+        /**
+         * Configures response to skip certain number of items
+         * @constructor
+         * @param {number} skip - Number of content items that will be skipped
+         */
+        constructor(public skip: number) {
+            if (skip < 0) {
+                throw Error(`'SkipParameter' must specify a positive integer number or zero."`);
+            }
+        }
+
+        getParam(): string {
+            return `skip=${this.skip}`;
+        }
+    }
+
+    export class OrderParameter implements IQueryParameter {
+        /**
+         * Sorts the response based on given element.
+         * @constructor
+         * @param {string} element - Element that will be used for sorting (can be both elements.<elementname> or system.<elementname>)
+         * @param {SortOrder} sortOrder - Order type (desc/asc). Defaults to 'asc' if SortOrder is null or invalid.
+         */
+        constructor(public element: string, public sortOrder: SortOrder) {
+            if (!element) {
+                throw Error(`Element specified in 'OrderParameter' is null or empty`);
+            }
+        }
+
+        getParam(): string {
+            return `order=${this.getParamValue()}`;
+        }
+
+        private getParamValue(): string | undefined {
+            return `${this.element.trim()}[${this.sortOrder}]`;
+        }
+    }
+
+    export class CustomParameter implements IQueryParameter {
+        constructor(public param: string) {}
+
+        getParam(): string {
+            return this.param;
+        }
+    }
+
+    export class DepthParameter implements IQueryParameter {
+        /**
+         * Configures the depth of the response. Content items might reference another 'linked items' using the Linked items element.
+         * Recursively, these linked items can reference another linked items.
+         * By default, only one level of linked content is returned.
+         * @constructor
+         * @param {number} depth - Depth fo the response
+         */
+        constructor(public depth: number) {
+            if (depth < 0) {
+                throw Error(`'DepthParameter' must specify a positive integer or zero`);
+            }
+        }
+
+        getParam(): string {
+            return `depth=${this.depth}`;
+        }
+    }
+
+    export class LanguageParameter implements IQueryParameter {
+        /**
+         * Specifies language version to fetch
+         * @constructor
+         * @param {string} languageCodename - Codename of the language
+         */
+        constructor(public languageCodename: string) {
+            if (!languageCodename) {
+                throw Error(`'LanguageParameter' must specify codename of the language`);
+            }
+        }
+
+        getParam(): string {
+            return `language=${this.languageCodename}`;
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export type SortOrder = 'asc' | 'desc';

package/lib/models/content-type-models.ts

@@ -0,0 +1,42 @@
+import { IQueryConfig } from './common/common-models';
+import { IGenericElement } from './element-models';
+
+export interface IContentTypeSystemAttributes {
+    /**
+     * Id of the type
+     */
+    id: string;
+
+    /**
+     * Name of the type
+     */
+    name: string;
+
+    /**
+     * Codename of the type
+     */
+    codename: string;
+
+    /**
+     * Date of last modification
+     */
+    lastModified: Date;
+}
+
+export interface IContentType {
+    /**
+     * Content type system attributes
+     */
+    system: IContentTypeSystemAttributes;
+
+    /**
+     * Elements (elements) assigned to content type
+     */
+    elements: IGenericElement[];
+}
+
+export interface IContentTypeQueryConfig extends IQueryConfig {
+    /**
+     * No dedicated properties required at this moment
+     */
+}

package/lib/models/element-models.ts

@@ -0,0 +1,51 @@
+import { IQueryConfig } from './common/common-models';
+
+export interface IElementQueryConfig extends IQueryConfig {
+    /**
+     * No dedicated properties required at this moment
+     */
+}
+
+export interface IGenericElementOption {
+    /**
+     * Name of the option
+     */
+    name: string;
+
+    /**
+     * Value of the option
+     */
+    codename: string;
+}
+
+export interface IGenericElement {
+    /**
+     * Indexer
+     */
+    [key: string]: any;
+
+    /**
+     * Codename of the element
+     */
+    codename: string;
+
+    /**
+     * Type of the element
+     */
+    type: string;
+
+    /**
+     * Name of the element
+     */
+    name: string;
+
+    /**
+     * Taxonomy group in case the element is a taxonomy
+     */
+    taxonomyGroup?: string;
+
+    /**
+     * Array of options if the element has some
+     */
+    options: IGenericElementOption[];
+}

package/lib/models/index.ts

@@ -0,0 +1,8 @@
+export * from './common';
+export * from './element-models';
+export * from './item-models';
+export * from './taxonomy-models';
+export * from './content-type-models';
+export * from './language-models';
+export * from './responses';
+

package/lib/models/item-models.ts

@@ -0,0 +1,130 @@
+import { Contracts } from '../contracts';
+import { IQueryConfig } from './common/common-models';
+import { ElementModels } from '../elements/element-models';
+
+export interface IMapElementsResult<TContentItem extends IContentItem = IContentItem> {
+    item: TContentItem;
+    processedItems: IContentItemsContainer;
+    preparedItems: IContentItemWithRawDataContainer;
+    processingStartedForCodenames: string[];
+}
+
+export interface IContentItemSystemAttributes {
+    /**
+     * Id of the item
+     */
+    id: string;
+
+    /**
+     * Name of the item
+     */
+    name: string;
+
+    /**
+     * Codename of the item
+     */
+    codename: string;
+
+    /**
+     * Codename of the type this item is using
+     */
+    type: string;
+
+    /**
+     * Date when the item was last modified
+     */
+    lastModified: string;
+
+    /**
+     * Codename of the language
+     */
+    language: string;
+
+    /**
+     * Array of sitemap locations (obsolete)
+     */
+    sitemapLocations: string[];
+
+    /**
+     * Codename of the collection this item belongs to
+     */
+    collection: string;
+
+    /**
+     * Workflow step of the item
+     */
+    workflowStep: string | null;
+}
+
+/**
+ * Indexer for elements within content item
+ */
+export type ContentItemElementsIndexer = ElementModels.IElement<any>;
+
+export type ContentItemType = 'component' | 'linkedItem';
+
+export interface IContentItemElements {
+    /**
+     * Indexer
+     */
+    [key: string]: ContentItemElementsIndexer;
+}
+
+export interface IContentItem<TElements extends IContentItemElements = IContentItemElements> {
+    /**
+     * Elements of the content item
+     */
+    elements: TElements;
+
+    /**
+     * System data of the content item
+     */
+    system: IContentItemSystemAttributes;
+}
+
+export interface ILink {
+    /**
+     * Id of the link
+     */
+    linkId: string;
+
+    /**
+     * Codename of the content item
+     */
+    codename: string;
+
+    /**
+     * Type codename of the content item
+     */
+    type: string;
+
+    /**
+     * Url slug defined for the content item
+     */
+    urlSlug: string;
+}
+
+export interface IContentItemWithRawElements {
+    item: IContentItem;
+    rawItem: Contracts.IContentItemContract;
+}
+
+export interface IContentItemWithRawDataContainer {
+    [key: string]: IContentItemWithRawElements;
+}
+
+export interface IContentItemsContainer {
+    [key: string]: IContentItem;
+}
+
+export interface IRichTextImage {
+    imageId: string;
+    url: string;
+    description: string | null;
+    width: number | null;
+    height: number | null;
+}
+
+export interface IItemQueryConfig extends IQueryConfig {}
+
+export type PropertyNameResolver = (contentTypeCodename: string, elementCodename: string) => string;

package/lib/models/language-models.ts

@@ -0,0 +1,17 @@
+import { IQueryConfig } from './common';
+
+export interface ILanguageSystem {
+    id: string;
+    name: string;
+    codename: string;
+}
+
+export interface ILanguage {
+    system: ILanguageSystem;
+}
+
+export interface ILanguagesQueryConfig extends IQueryConfig {
+    /**
+     * No dedicated properties required at this moment
+     */
+}

package/lib/models/responses.ts

@@ -0,0 +1,91 @@
+
+import {Contracts } from '../contracts';
+import { IDeliveryNetworkResponse } from './common/base-responses';
+import { IKontentListAllResponse, IKontentListResponse, IKontentResponse } from './common/common-models';
+import { IPagination } from './common/pagination.class';
+import { IContentType } from './content-type-models';
+import { IGenericElement } from './element-models';
+import { IContentItem, IContentItemsContainer } from './item-models';
+import { ILanguage } from './language-models';
+import { ITaxonomyGroup } from './taxonomy-models';
+
+export namespace Responses {
+    export interface IListContentTypesResponse extends IKontentListResponse {
+        items: IContentType[];
+        pagination: IPagination;
+    }
+
+    export interface IListContentTypesAllResponse extends IKontentListAllResponse {
+        items: IContentType[];
+        responses: IDeliveryNetworkResponse<IListContentTypesResponse, Contracts.IListContentTypeContract>[];
+    }
+
+    export interface IViewContentTypeResponse extends IKontentResponse {
+        type: IContentType;
+    }
+
+    export interface IViewContentTypeElementResponse extends IKontentResponse {
+        /**
+         * Response containing content type element
+         *
+         * @constructor
+         * @param {IGenericElement} element - Content type element
+         */
+        element: IGenericElement;
+    }
+
+    export interface IListItemsFeedResponse<TContentItem extends IContentItem = IContentItem>
+        extends IKontentListResponse {
+        items: TContentItem[];
+        linkedItems: IContentItemsContainer;
+    }
+
+    export interface IListItemsFeedAllResponse<TContentItem extends IContentItem = IContentItem>
+        extends IKontentListAllResponse {
+        items: TContentItem[];
+        responses: IDeliveryNetworkResponse<IListItemsFeedResponse<TContentItem>, Contracts.IItemsFeedContract>[];
+    }
+
+    export interface IListContentItemsResponse<TContentItem extends IContentItem = IContentItem>
+        extends IKontentListResponse {
+        items: TContentItem[];
+        pagination: IPagination;
+        linkedItems: IContentItemsContainer;
+    }
+
+    export interface IListContentItemsAllResponse<TContentItem extends IContentItem = IContentItem>
+        extends IKontentListAllResponse {
+        items: TContentItem[];
+        responses: IDeliveryNetworkResponse<IListContentItemsResponse<TContentItem>, Contracts.IListContentItemsContract>[];
+    }
+
+    export interface IViewContentItemResponse<TContentItem extends IContentItem = IContentItem>
+        extends IKontentResponse {
+        item: TContentItem;
+        linkedItems: IContentItemsContainer;
+    }
+
+    export interface IListLanguagesResponse extends IKontentListResponse {
+        items: ILanguage[];
+        pagination: IPagination;
+    }
+
+    export interface IListLanguagesAllResponse extends IKontentListAllResponse {
+        items: ILanguage[];
+        responses: IDeliveryNetworkResponse<IListLanguagesResponse, Contracts.IListLanguagesContract>[];
+    }
+
+    export interface IViewTaxonomyResponse extends IKontentResponse {
+        taxonomy: ITaxonomyGroup;
+    }
+
+    export interface IListTaxonomiesResponse extends IKontentListResponse {
+        items: ITaxonomyGroup[];
+        pagination: IPagination;
+    }
+
+    export interface IListTaxonomiesAllResponse extends IKontentListAllResponse {
+        items: ITaxonomyGroup[];
+        responses: IDeliveryNetworkResponse<IListTaxonomiesResponse, Contracts.IListTaxonomyGroupsContract>[];
+    }
+}

package/lib/models/taxonomy-models.ts

@@ -0,0 +1,25 @@
+import { IQueryConfig } from './common/common-models';
+
+export interface ITaxonomyGroup {
+    system: ITaxonomySystemAttributes;
+    terms: ITaxonomyTerms[];
+}
+
+export interface ITaxonomySystemAttributes {
+    id: string;
+    name: string;
+    codename: string;
+    lastModified: Date;
+}
+
+export interface ITaxonomyTerms {
+    name: string;
+    codename: string;
+    terms: ITaxonomyTerms[];
+}
+
+export interface ITaxonomyQueryConfig extends IQueryConfig {
+    /**
+     * No dedicated properties required at this moment
+     */
+}