ContentDeliveryAPI.ts

import Axios, { AxiosRequestConfig, Method, AxiosResponse, AxiosAdapter, AxiosPromise } from 'axios';
import AppConfig from './AppConfig';
import IContent from './Models/IContent';
import ContentLink, { ContentReference, ContentLinkService } from './Models/ContentLink';
import ActionResponse, { ResponseType } from './Models/ActionResponse';
import WebsiteList from './Models/WebsiteList';
import Website from './Models/Website';
import PathProvider from './PathProvider';
import Property from './Property';

export type PathResponse<T = any, C extends IContent = IContent> = C | ActionResponse<T, C>;

export type NetworkErrorData<T = any> = IContent & {
  error: Property<T>;
}

export function PathResponseIsIContent(iContent: PathResponse): iContent is IContent {
  if ((iContent as ActionResponse<any>).actionName) {
    return false;
  }
  return true;
}
export function PathResponseIsActionResponse<P extends any = any>(actionResponse: PathResponse): actionResponse is ActionResponse<P>
{
  if ((actionResponse as ActionResponse<P>).actionName) {
    return true;
  }
  return false;
}
export function getIContentFromPathResponse<IContentType extends IContent = IContent>(response: PathResponse<any, IContentType>) : IContentType | null
{
  if (PathResponseIsActionResponse(response)) {
    return response.currentContent;
  }
  if (PathResponseIsIContent(response)) {
    return response;
  }
  return null;
}

/**
 * ContentDelivery API Wrapper
 * 
 * @deprecated
 */
export class ContentDeliveryAPI {
  protected config: AppConfig;
  protected componentService: string = '/api/episerver/v2.0/content/';
  protected websiteService: string = '/api/episerver/v3/site/';
  protected methodService: string = '/api/episerver/v3/action/';
  protected debug: boolean = false;
  protected pathProvider: PathProvider;

  /**
   * Marker to keep if we're in edit mode
   */
  protected inEditMode: boolean = false;

  /**
   * Internal cache of the websites retrieved from the ContentDelivery API
   *
   * @private
   */
  private websites!: WebsiteList;

  /**
   * Internal cache of the current website, as retrieved from the ContentDelivery API
   *
   * @private
   */
  private website!: Website;

  /**
   * ContentDelivery API Wrapper
   * 
   * @deprecated
   */
  constructor(pathProvider: PathProvider, config: AppConfig) {
    this.pathProvider = pathProvider;
    this.config = config;
    this.debug = this.config.enableDebug === true;
  }

  public get currentPathProvider() : PathProvider
  {
    return this.pathProvider;
  }

  public get currentConfig() : AppConfig
  {
    return this.config;
  }

  public isInEditMode(): boolean {
    return this.inEditMode;
  }

  public setInEditMode(editMode: boolean): ContentDeliveryAPI {
    this.inEditMode = editMode === true;
    return this;
  }

  public isDisabled(): boolean {
    return this.config.noAjax === true;
  }

  /**
   * Invoke an ASP.Net MVC controller method using the generic content API. This is intended
   * to be used only when attaching a SPA to an existing code-base.
   *
   * @param content The content for which the controller must be loaded
   * @param method  The (case sensitive) method name to invoke on the controller
   * @param verb    The HTTP verb to use when invoking the controller
   * @param data    The data (if any) to send to the controller for the method
   */
  public async invokeControllerMethod(
    content: ContentLink,
    method: string,
    verb?: Method,
    data?: object,
  ): Promise<any> {
    let options = this.getRequestSettings(verb);
    options.data = data;
    return await this.doRequest<any>(this.getMethodServiceUrl(content, method), options);
  }

  /**
   * Strongly typed variant of invokeControllerMethod
   *
   * @see   invokeControllerMethod()
   * @param content The content for which the controller must be loaded
   * @param method  The (case sensitive) method name to invoke on the controller
   * @param verb    The HTTP verb to use when invoking the controller
   * @param data    The data (if any) to send to the controller for the method
   */
  public async invokeTypedControllerMethod<TypeOut, TypeIn>(
    content: ContentLink,
    method: string,
    verb?: Method,
    data?: TypeIn,
  ): Promise<ActionResponse<TypeOut>> {
    let options = this.getRequestSettings(verb);
    options.data = data;
    return await this.doRequest<ActionResponse<TypeOut>>(this.getMethodServiceUrl(content, method), options);
  }

  /**
   * Retrieve a list of all websites registered within Episerver
   */
  public async getWebsites(): Promise<WebsiteList> {
    if (!this.websites) {
      this.websites = await this.doRequest<WebsiteList>(this.config.epiBaseUrl + this.websiteService);
    }
    return this.websites;
  }

  /**
   * Retrieve the first website registered within Episerver
   */
  public async getWebsite(): Promise<Website> {
    const list = await this.getWebsites();
    return list[0];
  }

  public async getContent(content: ContentLink, forceGuid: boolean = false): Promise<IContent | null> {
    if (!(content && (content.guidValue || content.url))) {
      if (this.config.enableDebug) {
        console.warn('Loading content for an empty reference ', content);
      }
      return null;
    }
    let useGuid = content.guidValue ? this.config.preferGuid || forceGuid : false;
    let serviceUrl: URL;
    if (useGuid) {
      serviceUrl = new URL(this.config.epiBaseUrl + this.componentService + content.guidValue);
    } else {
      try {
        serviceUrl = new URL(
          this.config.epiBaseUrl +
            (content.url ? content.url : this.componentService + ContentLinkService.createApiId(content)),
        );
      } catch (e) {
        serviceUrl = new URL(this.config.epiBaseUrl + this.componentService + ContentLinkService.createApiId(content));
      }
    }
    //serviceUrl.searchParams.append('currentPageUrl', this.pathProvider.getCurrentPath());
    if (this.config.autoExpandRequests) {
      serviceUrl.searchParams.append('expand', '*');
    }
    return this.doRequest<PathResponse>(serviceUrl.href).catch((r) => {
      return this.buildNetworkError(r);
    }).then(r => getIContentFromPathResponse(r));
  }

  public async getContentsByRefs(refs: Array<string>): Promise<Array<IContent>> {
    if (!refs || refs.length == 0) {
      return Promise.resolve<Array<IContent>>([]);
    }
    let serviceUrl: URL = new URL(this.config.epiBaseUrl + this.componentService);
    serviceUrl.searchParams.append('references', refs.join(','));
    if (this.config.autoExpandRequests) {
      serviceUrl.searchParams.append('expand', '*');
    }
    return this.doRequest<Array<IContent>>(serviceUrl.href).catch((r) => {
      return [];
    });
  }

  public async getContentByRef(ref: string): Promise<IContent> {
    let serviceUrl: URL = new URL(this.config.epiBaseUrl + this.componentService + ref);
    if (this.config.autoExpandRequests) {
      serviceUrl.searchParams.append('expand', '*');
    }
    return this.doRequest<IContent>(serviceUrl.href).catch((r) => {
      return this.buildNetworkError(r);
    });
  }

  public async getContentByPath(path: string): Promise<PathResponse> {
    let serviceUrl: URL = new URL(this.config.epiBaseUrl + path);
    if (this.config.autoExpandRequests) {
      serviceUrl.searchParams.append('expand', '*');
    }
    //serviceUrl.searchParams.append('currentPageUrl', this.pathProvider.getCurrentPath());
    return this.doRequest<PathResponse>(serviceUrl.href).catch((r) => {
      return this.buildNetworkError(r, path);
    });
  }

  public async getContentChildren<T extends IContent>(id: ContentReference): Promise<Array<T>> {
    let itemId: string = ContentLinkService.createApiId(id);
    let serviceUrl: URL = new URL(this.config.epiBaseUrl + this.componentService + itemId + '/children');
    if (this.config.autoExpandRequests) {
      serviceUrl.searchParams.append('expand', '*');
    }
    return this.doRequest<Array<T>>(serviceUrl.href).catch((r) => {
      return [];
    });
  }

  public async getContentAncestors(link: ContentReference): Promise<Array<IContent>> {
    let itemId: string = ContentLinkService.createApiId(link);
    let serviceUrl: URL = new URL(`${this.config.epiBaseUrl}${this.componentService}${itemId}/ancestors`);
    if (this.config.autoExpandRequests) {
      serviceUrl.searchParams.append('expand', '*');
    }
    return this.doRequest<Array<IContent>>(serviceUrl.href).catch((r) => {
      return [];
    });
  }

  /**
   * Perform the actual request
   *
   * @param url The URL to request the data from
   * @param options The Request options to use
   */
  protected async doRequest<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
    if (this.isDisabled()) {
      return Promise.reject('The Content Delivery API has been disabled');
    }
    if (this.isInEditMode()) {
      let urlObj = new URL(url);
      urlObj.searchParams.append('epieditmode', 'True');
      //Add channel...
      //Add project...
      urlObj.searchParams.append('preventCache', Math.round(Math.random() * 100000000).toString());
      url = urlObj.href;
    }

    options = options ? options : this.getRequestSettings();
    if (this.debug) console.debug('Requesting: ' + url);
    options.url = url;
    return Axios.request<any, AxiosResponse<T>>(options)
      .then((response) => {
        if (this.debug) console.debug(`Response from ${url}:`, response.data);
        return response.data;
      })
      .catch((reason) => {
        if (this.debug) console.error(`Response from ${url}: HTTP Fetch error `, reason);
        throw reason;
      });
  }

  protected getMethodServiceUrl(content: ContentLink, method: string): string {
    let contentUrl: string = this.config.epiBaseUrl;
    contentUrl = contentUrl + this.methodService;
    contentUrl = contentUrl + content.guidValue + '/' + method;
    return contentUrl;
  }

  /**
   * Build the request parameters needed to perform the call to the Content Delivery API
   *
   * @param verb The verb for the generated configuration
   */
  protected getRequestSettings(verb?: Method): AxiosRequestConfig {

    let options: AxiosRequestConfig = {
      method: verb ? verb : 'get',
      baseURL: this.config.epiBaseUrl,
      withCredentials: true,
      headers: { ...this.getHeaders() },
      transformRequest: [
        (data: any, headers: any) => {
          if (data) {
            headers['Content-Type'] = 'application/json';
            return JSON.stringify(data);
          }
          return data;
        },
      ],
      responseType: 'json',
    };
    if (this.config.networkAdapter) {
      options.adapter = this.config.networkAdapter;
    }
    return options;
  }

  protected getHeaders(customHeaders?: object): object {
    let defaultHeaders = {
      Accept: 'application/json',
      'Accept-Language': this.config.defaultLanguage, //@ToDo: Convert to context call, with default
    };
    if (!customHeaders) return defaultHeaders;

    return {
      ...defaultHeaders,
      ...customHeaders,
    };
  }

  public static IsActionResponse(response: PathResponse): response is ActionResponse<any> {
    if (
      response &&
      (response as ActionResponse<any>).responseType &&
      (response as ActionResponse<any>).responseType == ResponseType.ActionResult
    ) {
      return true;
    }
    return false;
  }

  private counter: number = 0;

  protected buildNetworkError(reason: any, path: string = ''): NetworkErrorData {
    const errorId = ++this.counter;
    return {
      name: {
        propertyDataType: 'String',
        value: 'Error',
      },
      contentType: ['Errors', 'NetworkError'],
      contentLink: {
        guidValue: '',
        id: errorId,
        providerName: 'ContentDeliveryAPI_Errors',
        url: path,
        workId: 0,
      },
      error: {
        propertyDataType: 'Unknown',
        value: '', //reason,
      },
    };
  }
}

export default ContentDeliveryAPI;