@rudderstack/integrations-lib
Version:
112 lines • 13.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const factory_1 = require("../../network/factory");
const config_1 = require("./config");
/**
* CriteoAudience SDK for managing audience segments in Criteo
* @class
*/
class CriteoAudience {
/**
* Creates an instance of CriteoAudience
* @param {AuthObject} authObject - Authentication object containing access token and refresh function
* @throws {Error} If authObject is invalid or missing required properties
*/
constructor(authObject) {
CriteoAudience.validateAuthObject(authObject);
this.authObject = authObject;
this.httpClient = factory_1.HttpClientFactory.getHttpClient(factory_1.ClientNames.Axios, {
baseURL: config_1.BASE_URL,
});
}
/**
* Validates the authentication object
* @param {AuthObject} authObject - Authentication object to validate
* @throws {Error} If authObject is invalid or missing required properties
* @private
*/
static validateAuthObject(authObject) {
if (!authObject) {
throw new Error('authObject is required.');
}
const { accessToken, refreshAccessTokenFunc } = authObject;
if (!accessToken) {
throw new Error('Criteo Audience accessToken is required.');
}
if (!refreshAccessTokenFunc) {
throw new Error('Criteo Audience a refresh access token function is required.');
}
}
/**
* Refreshes the access token using the provided refresh function
* @throws {Error} If token refresh fails
* @private
*/
async refreshToken() {
try {
const accessToken = await this.authObject.refreshAccessTokenFunc();
this.authObject.accessToken = accessToken;
}
catch (error) {
throw new Error(`Unable to refresh token, with error: ${error}`);
}
}
/**
* Gets the request headers with authentication
* @returns {RequestConfig} Request configuration with headers
* @private
*/
getHeader() {
return {
headers: {
authorization: `Bearer ${this.authObject.accessToken}`,
accept: 'application/json',
'content-type': 'application/json',
},
};
}
/**
* Executes a POST request with token refresh handling
* @template T - Response type
* @param {string} url - API endpoint URL
* @param {object} data - Request payload
* @returns {Promise<ApiResponse<T>>} API response
* @private
*/
async executePostRequest(url, data) {
const response = await this.httpClient.post(url, data, this.getHeader());
switch (response.type) {
case 'application-error':
if (response.statusCode === 401 &&
(response.responseBody.errors[0].code === 'authorization-token-invalid' ||
response.responseBody.errors[0].code === 'authorization-token-expired')) {
await this.refreshToken();
return this.httpClient.post(url, data, this.getHeader());
}
return response;
default:
return response;
}
}
/**
* Creates a new audience segment in Criteo
* @param {AudienceSegmentBody} audienceSegmentBody - Audience segment data
* @returns {Promise<AudienceSegmentData>} Created audience segment data
* @throws {Error} If audience segment creation fails
*/
async createAudienceSegment(audienceSegmentBody) {
const createAudienceSegmentResponse = await this.executePostRequest(`/marketing-solutions/audience-segments/create`, audienceSegmentBody);
if (createAudienceSegmentResponse.type === 'success') {
const { data } = createAudienceSegmentResponse.responseBody;
if (data && data.length > 0) {
return data[0];
}
}
const errorMessage = createAudienceSegmentResponse.type === 'client-error'
? createAudienceSegmentResponse.message
: JSON.stringify(createAudienceSegmentResponse.responseBody);
throw new Error(`Failed to create audience segment, with error: ${errorMessage}`);
}
}
exports.default = CriteoAudience;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"criteoAudience.js","sourceRoot":"","sources":["../../../src/sdks/criteoAudience/criteoAudience.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClientFactory, ClientNames } from '../../network/factory';\nimport { HttpClient, RequestConfig, ApiResponse } from '../../network/clients/types';\nimport { BASE_URL } from './config';\nimport {\n  AuthObject,\n  AudienceSegmentBody,\n  AudienceSegmentResponse,\n  AudienceSegmentData,\n} from './types';\n\n/**\n * CriteoAudience SDK for managing audience segments in Criteo\n * @class\n */\nexport default class CriteoAudience {\n  private authObject: AuthObject;\n\n  private httpClient: HttpClient;\n\n  /**\n   * Creates an instance of CriteoAudience\n   * @param {AuthObject} authObject - Authentication object containing access token and refresh function\n   * @throws {Error} If authObject is invalid or missing required properties\n   */\n  constructor(authObject: AuthObject) {\n    CriteoAudience.validateAuthObject(authObject);\n    this.authObject = authObject;\n    this.httpClient = HttpClientFactory.getHttpClient(ClientNames.Axios, {\n      baseURL: BASE_URL,\n    });\n  }\n\n  /**\n   * Validates the authentication object\n   * @param {AuthObject} authObject - Authentication object to validate\n   * @throws {Error} If authObject is invalid or missing required properties\n   * @private\n   */\n  private static validateAuthObject(authObject: AuthObject) {\n    if (!authObject) {\n      throw new Error('authObject is required.');\n    }\n    const { accessToken, refreshAccessTokenFunc } = authObject;\n    if (!accessToken) {\n      throw new Error('Criteo Audience accessToken is required.');\n    }\n    if (!refreshAccessTokenFunc) {\n      throw new Error('Criteo Audience a refresh access token function is required.');\n    }\n  }\n\n  /**\n   * Refreshes the access token using the provided refresh function\n   * @throws {Error} If token refresh fails\n   * @private\n   */\n  private async refreshToken() {\n    try {\n      const accessToken = await this.authObject.refreshAccessTokenFunc();\n      this.authObject.accessToken = accessToken;\n    } catch (error) {\n      throw new Error(`Unable to refresh token, with error: ${error}`);\n    }\n  }\n\n  /**\n   * Gets the request headers with authentication\n   * @returns {RequestConfig} Request configuration with headers\n   * @private\n   */\n  private getHeader(): RequestConfig {\n    return {\n      headers: {\n        authorization: `Bearer ${this.authObject.accessToken}`,\n        accept: 'application/json',\n        'content-type': 'application/json',\n      },\n    };\n  }\n\n  /**\n   * Executes a POST request with token refresh handling\n   * @template T - Response type\n   * @param {string} url - API endpoint URL\n   * @param {object} data - Request payload\n   * @returns {Promise<ApiResponse<T>>} API response\n   * @private\n   */\n  private async executePostRequest<T>(url: string, data: object): Promise<ApiResponse<T>> {\n    const response = await this.httpClient.post<T>(url, data, this.getHeader());\n    switch (response.type) {\n      case 'application-error':\n        if (\n          response.statusCode === 401 &&\n          (response.responseBody.errors[0].code === 'authorization-token-invalid' ||\n            response.responseBody.errors[0].code === 'authorization-token-expired')\n        ) {\n          await this.refreshToken();\n          return this.httpClient.post<T>(url, data, this.getHeader());\n        }\n        return response;\n      default:\n        return response;\n    }\n  }\n\n  /**\n   * Creates a new audience segment in Criteo\n   * @param {AudienceSegmentBody} audienceSegmentBody - Audience segment data\n   * @returns {Promise<AudienceSegmentData>} Created audience segment data\n   * @throws {Error} If audience segment creation fails\n   */\n  public async createAudienceSegment(\n    audienceSegmentBody: AudienceSegmentBody,\n  ): Promise<AudienceSegmentData> {\n    const createAudienceSegmentResponse = await this.executePostRequest<AudienceSegmentResponse>(\n      `/marketing-solutions/audience-segments/create`,\n      audienceSegmentBody,\n    );\n    if (createAudienceSegmentResponse.type === 'success') {\n      const { data } = createAudienceSegmentResponse.responseBody;\n      if (data && data.length > 0) {\n        return data[0];\n      }\n    }\n\n    const errorMessage =\n      createAudienceSegmentResponse.type === 'client-error'\n        ? createAudienceSegmentResponse.message\n        : JSON.stringify(createAudienceSegmentResponse.responseBody);\n\n    throw new Error(`Failed to create audience segment, with error: ${errorMessage}`);\n  }\n}\n"]}