entry.ts

import { AxiosInstance, getData } from '@contentstack/core';
import { ErrorMessages } from '../common/error-messages';

interface EntryResponse<T> {
  entry: T;
}
export class Entry {
  protected _client: AxiosInstance;
  private _contentTypeUid: string;
  private _entryUid: string;
  private _urlPath: string;
  protected _variants: string;
  _queryParams: { [key: string]: string | number | string[] } = {};
  constructor(client: AxiosInstance, contentTypeUid: string, entryUid: string) {
    this._client = client;
    this._contentTypeUid = contentTypeUid;
    this._entryUid = entryUid;
    this._urlPath = `/content_types/${this._contentTypeUid}/entries/${this._entryUid}`;
    this._variants = '';
  }

  /**
   * @method includeFallback
   * @memberof Entry
   * @description When an entry is not published in a specific language, content can be fetched from its fallback language
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType(contentType_uid).entry(entry_uid).includeFallback().fetch();
   */
  includeFallback(): this {
    this._queryParams.include_fallback = 'true';

    return this;
  }

  /**
   * @method variants
   * @memberof Entry
   * @description The variant header will be added to axios client
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType('abc').entry('entry_uid').variants('xyz').fetch();
   */
  variants(variants: string | string[]): this {
    if (Array.isArray(variants) && variants.length > 0) {
      this._variants = variants.join(',');
    } else if (typeof variants == 'string' && variants.length > 0) {
      this._variants = variants;
    }

    return this;
  }

  /**
   * @method includeMetadata
   * @memberof Entry
   * @description Include the metadata for getting metadata content for the entry.
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType(contentType_uid).entry(entry_uid).includeMetadata().fetch();
   */
  includeMetadata(): this {
    this._queryParams.include_metadata = 'true';

    return this;
  }

  /**
   * @method includeEmbeddedItems
   * @memberof Entry
   * @description Include Embedded Objects (Entry and Assets) along with entry/entries details.
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType(contentType_uid).entry(entry_uid).includeEmbeddedItems().fetch();
   */
  includeEmbeddedItems(): this {
    this._queryParams['include_embedded_items[]'] = 'BASE';

    return this;
  }

  /**
   * @method includeReference
   * @memberof Entry
   * @description To include the content of the referred entry in your response,
   * you need to use the include[] parameter and specify the UID of the reference field as value.
   * This function sets the include parameter to a reference field UID in the API request.
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType("contentTypeUid").entry(entry_uid).includeReference("brand").fetch()
   *
   * @param {string} referenceFieldUid - UID of the reference field to include.
   * @returns {Entry} - Returns the Entry instance for chaining.
   */
  includeReference(...referenceFieldUid: (string | string[])[]): this {
    if (referenceFieldUid.length) {
      referenceFieldUid.forEach(value => {
        if (!Array.isArray(this._queryParams['include[]'])) {
          this._queryParams['include[]'] = [];
        }
        (this._queryParams['include[]'] as string[]).push(...(Array.isArray(value) ? value : [value]));
      });
    } else {
      console.error(ErrorMessages.INVALID_ARGUMENT_STRING_OR_ARRAY);
    }
    return this;
  }

  /**
   * @method includeContentType
   * @memberof Entry
   * @description Include the details of the content type along with the entries details
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType(contentType_uid).entry(entry_uid).includeContentType().fetch();
   */
  includeContentType(): this {
    this._queryParams.include_content_type = 'true';

    return this;
  }

  /**
   * @method includeBranch
   * @memberof Entry
   * @description Includes the branch in result
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType(contentType_uid).entry(entry_uid).includeBranch().fetch();
   */
  includeBranch(): this {
    this._queryParams.include_branch = 'true';

    return this;
  }

  /**
   * @method locale
   * @memberof Entry
   * @description The entry published in the locale will be fetched
   * @returns {Entry}
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType('contentTypeUid').entry('entryUid').locale('en-us').fetch();
   */
  locale(locale: string): this {
    this._queryParams.locale = locale;

    return this;
  }

  /**
   * @method fetch
   * @memberof Entry
   * @description Fetches the entry data on the basis of the entry uid
   * @returns {Promise<T>} Promise that resolves to the entry data
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType(contentType_uid).entry(entry_uid).fetch();
   */
  async fetch<T>(): Promise<T> {
    const getRequestOptions: any = { 
      params: this._queryParams,
      // Add contentTypeUid and entryUid to config for improved caching
      contentTypeUid: this._contentTypeUid,
      entryUid: this._entryUid
    };
    if (this._variants) {
      getRequestOptions.headers = {
        ...getRequestOptions.headers,
        'x-cs-variant-uid': this._variants
      };
    }

    const response = await getData(this._client, this._urlPath, getRequestOptions);

    if (response.entry) return response.entry as T;

    return response;
  }

  /**
   * @method addParams
   * @memberof Entry
   * @description Adds a query parameter to the query.
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType("contentTypeUid").entry("entryUid").addParams({"key": "value"}).fetch()
   *
   * @returns {Entry}
   */
  addParams(paramObj: { [key: string]: string | number | string[] }): this {
    this._queryParams = { ...this._queryParams, ...paramObj };

    return this;
  }

  /**
   * @method except
   * @memberof Entry
   * @description Excludes specific field/fields of an entry
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType("contentTypeUid").entry("entryUid").except("fieldUID").fetch()
   *
   * @param {string} fieldUid - field uid to exclude
   * @returns {Entry} - returns Entry object for chaining method calls
   */
  except(fieldUid: string|string[]): this {
    if (Array.isArray(fieldUid)) {
      let i = 0;
      for (const uid of fieldUid) {
        this._queryParams[`except[BASE][${i}]`] = uid;
        i++;
      }
    } else {
      this._queryParams["except[BASE][]"] = fieldUid;
    }

    return this;
  }

  /**
   * @method only
   * @memberof Entry
   * @description Selects specific field/fields of an entry
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType("contentTypeUid").entry("entryUid").only("fieldUID").fetch()
   *
   * @param {string} fieldUid - field uid to select
   * @returns {Entry} - returns Entry object for chaining method calls
   */
  only(fieldUid: string|string[]): this {
    if (Array.isArray(fieldUid)) {
      let i = 0;
      for (const uid of fieldUid) {
        this._queryParams[`only[BASE][${i}]`] = uid;
        i++;
      }
    } else {
      this._queryParams["only[BASE][]"] = fieldUid;
    }
    return this;
  }

  /**
   * @method assetFields
   * @memberof Entry
   * @description Include specific asset fields in the response (CDA getEntry).
   * Use with asset_fields[]: user_defined_fields, embedded_metadata, ai_generated_metadata, visual_markups.
   * @example
   * import contentstack from '@contentstack/delivery-sdk'
   *
   * const stack = contentstack.stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
   * const result = await stack.contentType("contentTypeUid").entry("entryUid").assetFields("user_defined_fields", "embedded_metadata").fetch();
   *
   * @param {...string} fields - Asset field names to include (e.g. user_defined_fields, embedded_metadata, ai_generated_metadata, visual_markups)
   * @returns {Entry} - Returns the Entry instance for chaining.
   */
  assetFields(...fields: string[]): this {
    if (fields.length > 0) {
      this._queryParams['asset_fields[]'] = fields;
    }
    return this;
  }
}