lokalise-mcp/dist/domains/languages/languages.service.js

The Lokalise MCP Server brings Lokalise's localization power to Claude and AI assistants—manage projects, keys, and translations by chat.

import { createUnexpectedError, McpError, } from "../../shared/utils/error.util.js";
import { Logger } from "../../shared/utils/logger.util.js";
import { getLokaliseApi } from "../../shared/utils/lokalise-api.util.js";
// Create a contextualized logger for this file
const serviceLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts");
// (Removed inline Lokalise API initialization logic)
// Log service initialization
serviceLogger.debug("Lokalise Languages API service initialized");
/**
 * @namespace VendorLanguagesService
 * @description Service layer for interacting with Lokalise Languages API endpoints.
 *              Uses the official Lokalise SDK for reliable API communication.
 */
/**
 * @function getSystemLanguages
 * @description Fetches a list of system languages from Lokalise API using the official SDK.
 * @memberof VendorLanguagesService
 * @param {ApiRequestOptions} [options={}] - Optional request options for pagination and limits.
 * @returns {Promise<Language[]>} A promise that resolves to an array of system language information.
 * @throws {McpError} Throws an `McpError` if the API call fails.
 */
async function getSystemLanguages(options = {}) {
    const methodLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts", "getSystemLanguages");
    methodLogger.debug("Calling Lokalise API for system languages", options);
    try {
        const api = getLokaliseApi();
        // Use SDK to fetch system languages
        const response = await api.languages().system_languages({
            limit: options.limit,
            page: options.page,
        });
        methodLogger.debug(`Received successful data from Lokalise API: ${response.items.length} system languages`);
        // Return the SDK response items directly as they match our Language type
        return response.items;
    }
    catch (error) {
        methodLogger.error("Service error fetching Lokalise system languages", error);
        // Rethrow other McpErrors
        if (error instanceof McpError) {
            throw error;
        }
        // Wrap any other unexpected errors
        throw createUnexpectedError("Unexpected service error while fetching Lokalise system languages", error);
    }
}
/**
 * @function getProjectLanguages
 * @description Fetches a list of languages for a specific project from Lokalise API using the official SDK.
 * @memberof VendorLanguagesService
 * @param {string} projectId - The project ID to get languages for.
 * @returns {Promise<Language[]>} A promise that resolves to an array of language information.
 * @throws {McpError} Throws an `McpError` if the API call fails.
 */
async function getProjectLanguages(projectId) {
    const methodLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts", "getProjectLanguages");
    methodLogger.debug("Calling Lokalise API for project languages", {
        projectId,
    });
    try {
        const api = getLokaliseApi();
        // Use SDK to fetch project languages
        const response = await api.languages().list({ project_id: projectId });
        methodLogger.debug(`Received project languages from Lokalise API: ${response.items.length} languages`);
        // Return the SDK response items directly as they match our Language type
        return response.items;
    }
    catch (error) {
        methodLogger.error("Service error fetching Lokalise project languages", error);
        // Rethrow other McpErrors
        if (error instanceof McpError) {
            throw error;
        }
        // Wrap any other unexpected errors
        throw createUnexpectedError("Unexpected service error while fetching Lokalise project languages", error);
    }
}
/**
 * @function addProjectLanguages
 * @description Adds languages to a project in Lokalise using the official SDK.
 * @memberof VendorLanguagesService
 * @param {string} projectId - The project ID to add languages to.
 * @param {CreateLanguageParams[]} languages - Array of language data to add.
 * @returns {Promise<Language[]>} A promise that resolves to an array of added languages.
 * @throws {McpError} Throws an `McpError` if the API call fails.
 */
async function addProjectLanguages(projectId, languages) {
    const methodLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts", "addProjectLanguages");
    methodLogger.debug("Adding languages to Lokalise project", {
        projectId,
        languageCount: languages.length,
    });
    try {
        const api = getLokaliseApi();
        // Use SDK to add languages
        const result = await api
            .languages()
            .create(languages, { project_id: projectId });
        methodLogger.debug(`Added languages successfully: ${result.items.length} languages added`);
        return result.items;
    }
    catch (error) {
        methodLogger.error("Service error adding Lokalise project languages", error);
        if (error instanceof McpError) {
            throw error;
        }
        throw createUnexpectedError("Unexpected service error while adding Lokalise project languages", error);
    }
}
/**
 * @function getLanguage
 * @description Fetches detailed information about a specific language from Lokalise API using the official SDK.
 * @memberof VendorLanguagesService
 * @param {string} projectId - The project ID.
 * @param {number} languageId - The language ID to get details for.
 * @returns {Promise<Language>} A promise that resolves to the language details.
 * @throws {McpError} Throws an `McpError` if the API call fails.
 */
async function getLanguage(projectId, languageId) {
    const methodLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts", "getLanguage");
    methodLogger.debug("Calling Lokalise API for language details", {
        projectId,
        languageId,
    });
    try {
        const api = getLokaliseApi();
        const language = await api
            .languages()
            .get(languageId, { project_id: projectId });
        methodLogger.debug(`Received language details from Lokalise API: ${language.lang_name}`);
        return language;
    }
    catch (error) {
        methodLogger.error("Service error fetching Lokalise language details", error);
        if (error instanceof McpError) {
            throw error;
        }
        throw createUnexpectedError("Unexpected service error while fetching Lokalise language details", error);
    }
}
/**
 * @function updateLanguage
 * @description Updates an existing language using the official SDK.
 * @memberof VendorLanguagesService
 * @param {string} projectId - The project ID.
 * @param {number} languageId - The language ID to update.
 * @param {UpdateLanguageParams} languageData - The language data to update.
 * @returns {Promise<Language>} A promise that resolves to the updated language.
 * @throws {McpError} Throws an `McpError` if the API call fails.
 */
async function updateLanguage(projectId, languageId, languageData) {
    const methodLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts", "updateLanguage");
    methodLogger.debug("Updating language in Lokalise project", {
        projectId,
        languageId,
        languageData,
    });
    try {
        const api = getLokaliseApi();
        const language = await api
            .languages()
            .update(languageId, languageData, { project_id: projectId });
        methodLogger.debug(`Updated language successfully: ${language.lang_name}`);
        return language;
    }
    catch (error) {
        methodLogger.error("Service error updating Lokalise language", error);
        if (error instanceof McpError) {
            throw error;
        }
        throw createUnexpectedError("Unexpected service error while updating Lokalise language", error);
    }
}
/**
 * @function removeLanguage
 * @description Removes a language from a project using the official SDK.
 * @memberof VendorLanguagesService
 * @param {string} projectId - The project ID.
 * @param {number} languageId - The language ID to remove.
 * @returns {Promise<{ project_id: string; language_deleted: boolean }>} A promise that resolves to confirmation of removal.
 * @throws {McpError} Throws an `McpError` if the API call fails.
 */
async function removeLanguage(projectId, languageId) {
    const methodLogger = Logger.forContext("services/vendor.lokalise.com.languages.service.ts", "removeLanguage");
    methodLogger.debug("Removing language from Lokalise project", {
        projectId,
        languageId,
    });
    try {
        const api = getLokaliseApi();
        const result = await api
            .languages()
            .delete(languageId, { project_id: projectId });
        methodLogger.debug(`Removed language successfully from project: ${projectId}`);
        return result;
    }
    catch (error) {
        methodLogger.error("Service error removing Lokalise language", error);
        if (error instanceof McpError) {
            throw error;
        }
        throw createUnexpectedError("Unexpected service error while removing Lokalise language", error);
    }
}
export default {
    getSystemLanguages,
    getProjectLanguages,
    addProjectLanguages,
    getLanguage,
    updateLanguage,
    removeLanguage,
};