@contentstack/cli-variants 0.0.1-alpha

package/lib/utils/personalization-api-adapter.js

@@ -0,0 +1,184 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonalizationAdapter = void 0;
+const adapter_helper_1 = require("./adapter-helper");
+const error_helper_1 = require("./error-helper");
+class PersonalizationAdapter extends adapter_helper_1.AdapterHelper {
+    constructor(options) {
+        super(options);
+    }
+    projects(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getProjectEndPoint = `/projects?connectedStackApiKey=${options.connectedStackApiKey}`;
+            const data = yield this.apiClient.get(getProjectEndPoint);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * This TypeScript function creates a project by making an asynchronous API call to retrieve project
+     * data.
+     * @param {CreateProjectInput} input - The `input` parameter in the `createProject` function likely
+     * represents the data needed to create a new project. It could include details such as the project
+     * name, description, owner, deadline, or any other relevant information required to set up a new
+     * project.
+     * @returns The `createProject` function is returning a Promise that resolves to either a
+     * `ProjectStruct` object or `void`.
+     */
+    createProject(project) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.post('/projects', project);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * The function `createAttribute` asynchronously retrieves attribute data from an API endpoint.
+     * @param {CreateAttributeInput} input - The `input` parameter in the `createAttribute` function is
+     * of type `CreateAttributeInput`. This parameter likely contains the necessary data or information
+     * needed to create a new attribute.
+     * @returns The `createAttribute` function is returning the data obtained from a GET request to the
+     * `/attributes` endpoint using the `apiClient` with the input provided. The data returned is of type
+     * `ProjectStruct`.
+     */
+    createAttribute(attribute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.post('/attributes', attribute);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    getExperiences() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getExperiencesEndPoint = `/experiences`;
+            const data = yield this.apiClient.get(getExperiencesEndPoint);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    getExperience(experienceUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getExperiencesEndPoint = `/experiences/${experienceUid}`;
+            const data = yield this.apiClient.get(getExperiencesEndPoint);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    getVariantGroup(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cmaAPIClient) {
+                const getVariantGroupEndPoint = `/variant_groups`;
+                const data = yield this.cmaAPIClient
+                    .queryParams({ experience_uid: input.experienceUid })
+                    .get(getVariantGroupEndPoint);
+                return this.handleVariantAPIRes(data);
+            }
+        });
+    }
+    updateVariantGroup(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cmaAPIClient) {
+                const updateVariantGroupEndPoint = `/variant_groups/${input.uid}`;
+                const data = yield this.cmaAPIClient.put(updateVariantGroupEndPoint, input);
+                return this.handleVariantAPIRes(data);
+            }
+        });
+    }
+    getEvents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.get('/events');
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    createEvents(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.post('/events', event);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    getAudiences() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.get('/audiences');
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    getAttributes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.get('/attributes');
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * @param {CreateAudienceInput} audience - The `audience` parameter in the `createAudience` function is
+     * of type `CreateAudienceInput`. This parameter likely contains the necessary data or information
+     * needed to create a new audience.
+     * @returns The `createAudience` function is returning the data obtained from a GET request to the
+     * `/audiences` endpoint using the `apiClient` with the input provided. The data returned is of type
+     * `AudienceStruct`.
+     */
+    createAudience(audience) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.post('/audiences', audience);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * @param {CreateExperienceInput} experience - The `experience` parameter in the `createExperience` function is
+     * of type `CreateExperienceInput`. This parameter likely contains the necessary data or information
+     * needed to create a new audience.
+     * @returns The `createExperience` function is returning the data obtained from a GET request to the
+     * `/experiences` endpoint using the `apiClient` with the input provided. The data returned is of type
+     * `ExperienceStruct`.
+     */
+    createExperience(experience) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.apiClient.post('/experiences', experience);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * @param {UpdateExperienceInput} experience - The `experience` parameter in the `updateCTsInExperience` function is
+     * of type `UpdateExperienceInput`. This parameter likely contains the necessary data or information
+     * needed to attach CT in new created experience.
+     */
+    updateCTsInExperience(experience, experienceUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updateCTInExpEndPoint = `/experiences/${experienceUid}/cms-integration/variant-group`;
+            const data = yield this.apiClient.post(updateCTInExpEndPoint, experience);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * @param {UpdateExperienceInput} experienceUid - The `experienceUid` parameter in the `getCTsFromExperience` function is
+     * of type `string`. This parameter likely contains the necessary data or information
+     * needed to fetch CT details related to experience.
+     */
+    getCTsFromExperience(experienceUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getCTFromExpEndPoint = `/experiences/${experienceUid}/cms-integration/variant-group`;
+            const data = yield this.apiClient.get(getCTFromExpEndPoint);
+            return this.handleVariantAPIRes(data);
+        });
+    }
+    /**
+     * Handles the API response for variant requests.
+     * @param res - The API response object.
+     * @returns The variant API response data.
+     * @throws If the API response status is not within the success range, an error message is thrown.
+     */
+    handleVariantAPIRes(res) {
+        const { status, data } = res;
+        if (status >= 200 && status < 300) {
+            return data;
+        }
+        const errorMsg = (data === null || data === void 0 ? void 0 : data.errors)
+            ? (0, error_helper_1.formatErrors)(data.errors)
+            : (data === null || data === void 0 ? void 0 : data.error_message) || (data === null || data === void 0 ? void 0 : data.message) || 'Something went wrong while processing variant entries request!';
+        throw errorMsg;
+    }
+}
+exports.PersonalizationAdapter = PersonalizationAdapter;

package/lib/utils/variant-api-adapter.d.ts

@@ -0,0 +1,79 @@
+import { HttpClient, HttpClientOptions, ContentstackClient, ContentstackConfig } from '@contentstack/cli-utilities';
+import { APIConfig, AdapterType, AnyProperty, VariantOptions, VariantsOption, VariantInterface, VariantEntryStruct, CreateVariantEntryDto, CreateVariantEntryOptions, APIResponse, PublishVariantEntryDto, PublishVariantEntryOptions } from '../types';
+import messages from '../messages';
+import { AdapterHelper } from './adapter-helper';
+export declare class VariantHttpClient<C> extends AdapterHelper<C, HttpClient> implements VariantInterface<C, HttpClient> {
+    baseURL: string;
+    constructor(config: APIConfig, options?: HttpClientOptions);
+    variantEntry(options: VariantOptions): Promise<{
+        entry: {};
+    }>;
+    /**
+     * The function `variantEntries` retrieves variant entries based on specified options and stores them
+     * in an array.
+     * @param {VariantsOption} options - The `options` parameter in the `variantEntries` function is an
+     * object that contains the following properties:
+     * @param {Record<string, any>[]} entries - The `entries` parameter in the `variantEntries` function
+     * is an array of objects where each object represents a record with key-value pairs. This parameter
+     * is used to store the entries retrieved from the API response or passed down recursively when
+     * fetching all data.
+     * @returns The function `variantEntries` returns a Promise that resolves to an object with an
+     * `entries` property containing an array of record objects or an unknown array. The function can
+     * also return void if certain conditions are not met.
+     */
+    variantEntries(options: VariantsOption, entries?: Record<string, any>[]): Promise<{
+        entries?: Record<string, any>[] | unknown[];
+    } | void>;
+    /**
+     * Creates a variant entry.
+     *
+     * @param input - The input data for the variant entry.
+     * @param options - The options for creating the variant entry.
+     * @param apiParams - Additional parameters for the API.
+     * @returns A Promise that resolves to a VariantEntryStruct, a string, or void.
+     */
+    createVariantEntry(input: CreateVariantEntryDto, options: CreateVariantEntryOptions, apiParams: Record<string, any>): Promise<VariantEntryStruct | string | void>;
+    /**
+     * Publishes a variant entry.
+     *
+     * @param input - The input data for publishing the variant entry.
+     * @param options - The options for publishing the variant entry.
+     * @param apiParams - Additional API parameters.
+     * @returns A Promise that resolves to the published variant entry response.
+     */
+    publishVariantEntry(input: PublishVariantEntryDto, options: PublishVariantEntryOptions, apiParams: Record<string, any>): Promise<void>;
+    /**
+     * Handles the API response for variant requests.
+     * @param res - The API response object.
+     * @returns The variant API response data.
+     * @throws If the API response status is not within the success range, an error message is thrown.
+     */
+    handleVariantAPIRes(res: APIResponse): VariantEntryStruct | {
+        entries: VariantEntryStruct[];
+        count: number;
+    } | string | any;
+}
+export declare class VariantManagementSDK<T> extends AdapterHelper<T, ContentstackClient> implements VariantInterface<T, ContentstackClient> {
+    apiClient: ContentstackClient;
+    init(): Promise<void>;
+    variantEntry(options: VariantOptions): Promise<{
+        entry: {};
+    }>;
+    variantEntries(options: VariantsOption): Promise<{
+        entries: {}[];
+    }>;
+    createVariantEntry(input: CreateVariantEntryDto, options: CreateVariantEntryOptions, apiParams: Record<string, any>): Promise<VariantEntryStruct | string | void>;
+    handleVariantAPIRes(res: APIResponse): VariantEntryStruct | {
+        entries: VariantEntryStruct[];
+        count: number;
+    } | string;
+    constructQuery(query: Record<string, any>): string | void;
+    delay(ms: number): Promise<void>;
+}
+export declare class VariantAdapter<T> {
+    protected variantInstance: T;
+    readonly messages: typeof messages;
+    constructor(config: ContentstackConfig & AnyProperty & AdapterType<T, ContentstackConfig>);
+    constructor(config: APIConfig & AdapterType<T, APIConfig & AnyProperty>, options?: HttpClientOptions);
+}
+export default VariantAdapter;

package/lib/utils/variant-api-adapter.js

@@ -0,0 +1,263 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariantAdapter = exports.VariantManagementSDK = exports.VariantHttpClient = void 0;
+const omit_1 = __importDefault(require("lodash/omit"));
+const fs_1 = require("fs");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const messages_1 = __importDefault(require("../messages"));
+const adapter_helper_1 = require("./adapter-helper");
+const error_helper_1 = require("./error-helper");
+class VariantHttpClient extends adapter_helper_1.AdapterHelper {
+    constructor(config, options) {
+        var _a;
+        super(config, options);
+        this.baseURL = ((_a = config.baseURL) === null || _a === void 0 ? void 0 : _a.includes('http')) ? `${config.baseURL}/v3` : `https://${config.baseURL}/v3`;
+        this.apiClient.baseUrl(this.baseURL);
+    }
+    variantEntry(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO single entry variant
+            return { entry: {} };
+        });
+    }
+    /**
+     * The function `variantEntries` retrieves variant entries based on specified options and stores them
+     * in an array.
+     * @param {VariantsOption} options - The `options` parameter in the `variantEntries` function is an
+     * object that contains the following properties:
+     * @param {Record<string, any>[]} entries - The `entries` parameter in the `variantEntries` function
+     * is an array of objects where each object represents a record with key-value pairs. This parameter
+     * is used to store the entries retrieved from the API response or passed down recursively when
+     * fetching all data.
+     * @returns The function `variantEntries` returns a Promise that resolves to an object with an
+     * `entries` property containing an array of record objects or an unknown array. The function can
+     * also return void if certain conditions are not met.
+     */
+    variantEntries(options_1) {
+        return __awaiter(this, arguments, void 0, function* (options, entries = []) {
+            const variantConfig = this.config.modules.variantEntry;
+            const { callback, entry_uid, getAllData, returnResult, content_type_uid, locale, skip = variantConfig.query.skip || 0, limit = variantConfig.query.limit || 100, include_variant = variantConfig.query.include_variant || true, include_count = variantConfig.query.include_count || true, include_publish_details = variantConfig.query.include_publish_details || true, } = options;
+            if (variantConfig.serveMockData && callback) {
+                let data = [];
+                if ((0, fs_1.existsSync)(variantConfig.mockDataPath)) {
+                    data = require(variantConfig.mockDataPath);
+                }
+                callback(data);
+                return;
+            }
+            if (!locale)
+                return;
+            const start = Date.now();
+            let endpoint = `/content_types/${content_type_uid}/entries/${entry_uid}/variants?locale=${locale}`;
+            if (skip) {
+                endpoint = endpoint.concat(`&skip=${skip}`);
+            }
+            if (limit) {
+                endpoint = endpoint.concat(`&limit=${limit}`);
+            }
+            if (include_variant) {
+                endpoint = endpoint.concat(`&include_variant=${include_variant}`);
+            }
+            if (include_count) {
+                endpoint = endpoint.concat(`&include_count=${include_count}`);
+            }
+            if (include_publish_details) {
+                endpoint = endpoint.concat(`&include_publish_details=${include_publish_details}`);
+            }
+            const query = this.constructQuery((0, omit_1.default)(variantConfig.query, [
+                'skip',
+                'limit',
+                'locale',
+                'include_variant',
+                'include_count',
+                'include_publish_details',
+            ]));
+            if (query) {
+                endpoint = endpoint.concat(query);
+            }
+            const data = yield this.apiClient.get(endpoint);
+            const response = this.handleVariantAPIRes(data);
+            if (callback) {
+                callback(response.entries);
+            }
+            else {
+                entries = entries.concat(response.entries);
+            }
+            if (getAllData && skip + limit < response.count) {
+                const end = Date.now();
+                const exeTime = end - start;
+                if (exeTime < 1000) {
+                    // 1 API call per second
+                    yield this.delay(1000 - exeTime);
+                }
+                if (!options.skip) {
+                    options['skip'] = 0;
+                }
+                options.skip += limit;
+                return yield this.variantEntries(options, entries);
+            }
+            if (returnResult)
+                return { entries };
+        });
+    }
+    /**
+     * Creates a variant entry.
+     *
+     * @param input - The input data for the variant entry.
+     * @param options - The options for creating the variant entry.
+     * @param apiParams - Additional parameters for the API.
+     * @returns A Promise that resolves to a VariantEntryStruct, a string, or void.
+     */
+    createVariantEntry(input, options, apiParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { reject, resolve, variantUid, log } = apiParams;
+            const variantConfig = this.config.modules.variantEntry;
+            const { locale = variantConfig.query.locale || 'en-us', variant_id, entry_uid, content_type_uid } = options;
+            let endpoint = `content_types/${content_type_uid}/entries/${entry_uid}/variants/${variant_id}?locale=${locale}`;
+            const query = this.constructQuery((0, omit_1.default)(variantConfig.query, ['locale']));
+            if (query) {
+                endpoint = endpoint.concat(query);
+            }
+            const onSuccess = (response) => resolve({ response, apiData: { variantUid, entryUid: entry_uid }, log });
+            const onReject = (error) => reject({
+                error,
+                apiData: { variantUid, entryUid: entry_uid },
+                log,
+            });
+            try {
+                const res = yield this.apiClient.put(endpoint, { entry: input });
+                const data = this.handleVariantAPIRes(res);
+                if (res.status >= 200 && res.status < 300) {
+                    onSuccess(data);
+                }
+                else {
+                    onReject(data);
+                }
+            }
+            catch (error) {
+                onReject(error);
+            }
+        });
+    }
+    /**
+     * Publishes a variant entry.
+     *
+     * @param input - The input data for publishing the variant entry.
+     * @param options - The options for publishing the variant entry.
+     * @param apiParams - Additional API parameters.
+     * @returns A Promise that resolves to the published variant entry response.
+     */
+    publishVariantEntry(input, options, apiParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { reject, resolve, log, variantUid } = apiParams;
+            const { entry_uid, content_type_uid } = options;
+            let endpoint = `content_types/${content_type_uid}/entries/${entry_uid}/publish`;
+            const onSuccess = (response) => resolve({ response, apiData: { entryUid: entry_uid, variantUid }, log });
+            const onReject = (error) => reject({
+                error,
+                apiData: { entryUid: entry_uid, variantUid },
+                log,
+            });
+            try {
+                this.apiClient.headers({ api_version: 3.2 });
+                const res = yield this.apiClient.post(endpoint, input);
+                const data = this.handleVariantAPIRes(res);
+                if (res.status >= 200 && res.status < 300) {
+                    onSuccess(data);
+                }
+                else {
+                    onReject(data);
+                }
+            }
+            catch (error) {
+                onReject(error);
+            }
+        });
+    }
+    /**
+     * Handles the API response for variant requests.
+     * @param res - The API response object.
+     * @returns The variant API response data.
+     * @throws If the API response status is not within the success range, an error message is thrown.
+     */
+    handleVariantAPIRes(res) {
+        const { status, data } = res;
+        if (status >= 200 && status < 300) {
+            return data;
+        }
+        const errorMsg = (data === null || data === void 0 ? void 0 : data.errors)
+            ? (0, error_helper_1.formatErrors)(data.errors)
+            : (data === null || data === void 0 ? void 0 : data.error_message) || (data === null || data === void 0 ? void 0 : data.message) || 'Something went wrong while processing entry variant request!';
+        throw errorMsg;
+    }
+}
+exports.VariantHttpClient = VariantHttpClient;
+class VariantManagementSDK extends adapter_helper_1.AdapterHelper {
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.apiClient = yield (0, cli_utilities_1.managementSDKClient)(this.config);
+        });
+    }
+    variantEntry(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO SDK implementation
+            return { entry: {} };
+        });
+    }
+    variantEntries(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO SDK implementation
+            return { entries: [{}] };
+        });
+    }
+    createVariantEntry(input, options, apiParams) {
+        // FIXME placeholder
+        return Promise.resolve({});
+    }
+    handleVariantAPIRes(res) {
+        return res.data;
+    }
+    constructQuery(query) { }
+    delay(ms) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}
+exports.VariantManagementSDK = VariantManagementSDK;
+class VariantAdapter {
+    constructor(config, options) {
+        if (config.httpClient) {
+            const { httpClient, Adapter } = config, restConfig = __rest(config, ["httpClient", "Adapter"]);
+            this.variantInstance = new Adapter(restConfig, options);
+        }
+        else {
+            const { Adapter } = config, restConfig = __rest(config, ["Adapter"]);
+            this.variantInstance = new Adapter(restConfig);
+        }
+        this.messages = messages_1.default;
+    }
+}
+exports.VariantAdapter = VariantAdapter;
+exports.default = VariantAdapter;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@contentstack/cli-variants",
+  "version": "0.0.1-alpha",
+  "description": "Variants plugin",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "prepack": "pnpm compile",
+    "compile": "tsc -b tsconfig.json",
+    "test": "mocha --require ts-node/register --forbid-only \"test/**/*.test.ts\"",
+    "clean": "rm -rf ./lib ./node_modules tsconfig.build.tsbuildinfo",
+    "test:unit:report": "nyc --extension .ts mocha --require ts-node/register --forbid-only \"test/unit/**/*.test.ts\""
+  },
+  "keywords": [
+    "variant"
+  ],
+  "author": "antony.raj@contentstack.com",
+  "license": "MIT",
+  "devDependencies": {
+    "@contentstack/cli-dev-dependencies": "^1.2.4",
+    "@oclif/test": "^2.5.6",
+    "@types/chai": "^4.3.14",
+    "@types/node": "^20.12.7",
+    "chai": "^4.4.1",
+    "mocha": "^10.4.0",
+    "nyc": "^15.1.0",
+    "sinon": "^17.0.1",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.6.2",
+    "typescript": "^5.4.2"
+  },
+  "dependencies": {
+    "@contentstack/cli-utilities": "^1.5.12",
+    "lodash": "^4.17.21",
+    "mkdirp": "^1.0.4",
+    "winston": "^3.7.2"
+  }
+}

package/src/export/attributes.ts

@@ -0,0 +1,55 @@
+import omit from 'lodash/omit';
+import { resolve as pResolve } from 'node:path';
+import { sanitizePath } from '@contentstack/cli-utilities';
+import { formatError, fsUtil, PersonalizationAdapter, log } from '../utils';
+import { PersonalizationConfig, ExportConfig, AttributesConfig, AttributeStruct } from '../types';
+
+export default class ExportAttributes extends PersonalizationAdapter<ExportConfig> {
+  private attributesConfig: AttributesConfig;
+  private attributesFolderPath: string;
+  private attributes: Record<string, unknown>[];
+  public personalizationConfig: PersonalizationConfig;
+
+  constructor(readonly exportConfig: ExportConfig) {
+    super({
+      config: exportConfig,
+      baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+      headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+    });
+    this.personalizationConfig = exportConfig.modules.personalization;
+    this.attributesConfig = exportConfig.modules.attributes;
+    this.attributesFolderPath = pResolve(
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.personalizationConfig.dirName),
+      sanitizePath(this.attributesConfig.dirName),
+    );
+    this.attributes = [];
+  }
+
+  async start() {
+    try {
+      log(this.exportConfig, 'Starting attributes export', 'info');
+      await fsUtil.makeDirectory(this.attributesFolderPath);
+      this.attributes = (await this.getAttributes()) as AttributeStruct[];
+
+      if (!this.attributes?.length) {
+        log(this.exportConfig, 'No Attributes found with the given project!', 'info');
+      } else {
+        this.sanitizeAttribs();
+        fsUtil.writeFile(pResolve(sanitizePath(this.attributesFolderPath), sanitizePath(this.attributesConfig.fileName)), this.attributes);
+        log(this.exportConfig, 'All the attributes have been exported successfully!', 'success');
+      }
+    } catch (error) {
+      log(this.exportConfig, `Failed to export attributes!`, 'error');
+      log(this.config, error, 'error');
+    }
+  }
+
+  /**
+   * function to remove invalid keys from attributes object
+   */
+  sanitizeAttribs() {
+    this.attributes = this.attributes?.map((audience) => omit(audience, this.attributesConfig.invalidKeys)) || [];
+  }
+}

package/src/export/audiences.ts

@@ -0,0 +1,57 @@
+import omit from 'lodash/omit';
+import { resolve as pResolve } from 'node:path';
+
+import { formatError, fsUtil, PersonalizationAdapter, log } from '../utils';
+import { PersonalizationConfig, ExportConfig, AudienceStruct, AudiencesConfig } from '../types';
+
+export default class ExportAudiences extends PersonalizationAdapter<ExportConfig> {
+  private audiencesConfig: AudiencesConfig;
+  private audiencesFolderPath: string;
+  private audiences: Record<string, unknown>[];
+  public personalizationConfig: PersonalizationConfig;
+
+  constructor(readonly exportConfig: ExportConfig) {
+    super({
+      config: exportConfig,
+      baseURL: exportConfig.modules.personalization.baseURL[exportConfig.region.name],
+      headers: { authtoken: exportConfig.auth_token, 'X-Project-Uid': exportConfig.project_id },
+    });
+    this.personalizationConfig = exportConfig.modules.personalization;
+    this.audiencesConfig = exportConfig.modules.audiences;
+    this.audiencesFolderPath = pResolve(
+      exportConfig.data,
+      exportConfig.branchName || '',
+      this.personalizationConfig.dirName,
+      this.audiencesConfig.dirName,
+    );
+    this.audiences = [];
+  }
+
+  async start() {
+    try {
+      log(this.exportConfig, 'Starting audiences export', 'info');
+      await fsUtil.makeDirectory(this.audiencesFolderPath);
+      this.audiences = (await this.getAudiences()) as AudienceStruct[];
+
+      if (!this.audiences?.length) {
+        log(this.exportConfig, 'No Audiences found with the given project!', 'info');
+        return;
+      } else {
+        this.sanitizeAttribs();
+        fsUtil.writeFile(pResolve(this.audiencesFolderPath, this.audiencesConfig.fileName), this.audiences);
+        log(this.exportConfig, 'All the audiences have been exported successfully!', 'success');
+        return;
+      }
+    } catch (error) {
+      log(this.exportConfig, `Failed to export audiences!`, 'error');
+      log(this.config, error, 'error');
+    }
+  }
+
+  /**
+   * function to remove invalid keys from audience object
+   */
+  sanitizeAttribs() {
+    this.audiences = this.audiences?.map((audience) => omit(audience, this.audiencesConfig.invalidKeys)) || [];
+  }
+}