@contentstack/cli-cm-seed/lib/seed/contentstack/client.js

create a Stack from existing content types, entries, assets, etc.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const error_1 = require("./error");
const cli_utilities_1 = require("@contentstack/cli-utilities");
class ContentstackClient {
    constructor(cmaHost, limit) {
        this.instance = (0, cli_utilities_1.managementSDKClient)({ host: cmaHost });
        this.limit = limit || 100;
    }
    async getOrganization(org_uid) {
        try {
            const client = await this.instance;
            const response = await client.organization(org_uid).fetch();
            return {
                uid: response.uid,
                name: response.name,
                enabled: response.enabled,
            };
        }
        catch (error) {
            throw this.buildError(error);
        }
    }
    async getOrganizations(skip = 0, organizations = []) {
        try {
            const client = await this.instance;
            const configOrgUid = cli_utilities_1.configHandler.get('oauthOrgUid');
            if (configOrgUid) {
                const response = await client.organization(configOrgUid).fetch();
                const mappedOrganization = this.mapOrganization(response);
                organizations.push(mappedOrganization);
            }
            else {
                const response = await client
                    .organization()
                    .fetchAll({ limit: this.limit, asc: 'name', include_count: true, skip });
                organizations.push(...response.items.map(this.mapOrganization));
                if (organizations.length < response.count) {
                    organizations = await this.getOrganizations(skip + this.limit, organizations);
                }
            }
            return organizations;
        }
        catch (error) {
            throw this.buildError(error);
        }
    }
    mapOrganization(o) {
        return {
            uid: o.uid,
            name: o.name,
            enabled: o.enabled,
        };
    }
    async getStack(stackUID) {
        try {
            const client = await this.instance;
            const response = await client.stack({ api_key: stackUID }).fetch();
            return {
                uid: response.uid,
                name: response.name,
                master_locale: response.master_locale,
                api_key: response.api_key,
                org_uid: response.org_uid,
            };
        }
        catch (error) {
            throw this.buildError(error);
        }
    }
    async getStacks(org_uid, skip = 0, stacks = []) {
        try {
            const client = await this.instance;
            const response = await client
                .stack({ organization_uid: org_uid })
                .query({
                limit: this.limit,
                include_count: true,
                skip: skip,
                query: {},
            })
                .find();
            stacks = stacks.concat(response.items.map((s) => {
                return {
                    uid: s.uid,
                    name: s.name,
                    master_locale: s.master_locale,
                    api_key: s.api_key,
                    org_uid: s.org_uid,
                };
            }));
            if (stacks.length < response.count) {
                stacks = await this.getStacks(org_uid, skip + this.limit, stacks);
            }
            return stacks;
        }
        catch (error) {
            throw this.buildError(error);
        }
    }
    async getContentTypeCount(api_key, managementToken) {
        try {
            const client = await this.instance;
            const response = await client
                .stack({ api_key: api_key, management_token: managementToken })
                .contentType()
                .query({ include_count: true })
                .find();
            return response.count;
        }
        catch (error) {
            throw this.buildError(error);
        }
    }
    async createStack(options) {
        try {
            const client = await this.instance;
            const body = {
                stack: {
                    name: options.name,
                    description: options.description,
                    master_locale: options.master_locale,
                },
            };
            const response = await client.stack().create(body, { organization_uid: options.org_uid });
            return {
                uid: response.uid,
                api_key: response.api_key,
                master_locale: response.master_locale,
                name: response.name,
                org_uid: response.org_uid,
            };
        }
        catch (error) {
            throw this.buildError(error);
        }
    }
    async createManagementToken(api_key, managementToken, options) {
        try {
            const client = await this.instance;
            const body = {
                token: {
                    name: options.name,
                    description: options.description,
                    scope: options.scope,
                    expires_on: options.expires_on,
                },
            };
            const response = await client.stack({ api_key: api_key, management_token: managementToken }).managementToken().create(body);
            return {
                response_code: response.errorCode,
                response_message: response.errorMessage
            };
        }
        catch (error) {
            const typedError = error;
            if (typedError.errorCode === '401') {
                return {
                    response_code: '401',
                    response_message: 'You do not have access to create management tokens. Please try again or ask an Administrator for assistance.'
                };
            }
            throw this.buildError(typedError);
        }
    }
    buildError(error) {
        var _a;
        const message = error.errorMessage || ((_a = error.response.data) === null || _a === void 0 ? void 0 : _a.errorMessage) || error.response.statusText;
        const status = error.status;
        return new error_1.default(message, status);
    }
}
exports.default = ContentstackClient;