@kontent-ai/delivery-sdk 16.4.3 → 16.4.4

package/lib/mappers/taxonomy.mapper.ts

@@ -1,77 +1,77 @@
-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;
-    }
-}
+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 +1,76 @@
-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
-        };
-    }
-}
+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 +1,20 @@
-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
-            }
-        };
-    }
-}
+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 +1,13 @@
-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>[];
-}
+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 +1,118 @@
-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;
-    }
-}
+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;
+    }
+}