lokalise-mcp/dist/domains/teamusers/teamusers.controller.js

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

import { ErrorType, McpError } from "../../shared/utils/error.util.js";
import { handleControllerError } from "../../shared/utils/error-handler.util.js";
import { Logger } from "../../shared/utils/logger.util.js";
import { formatDeleteTeamusersResult, formatTeamusersDetails, formatTeamusersList, formatUpdateTeamusersResult, } from "./teamusers.formatter.js";
import { teamusersService } from "./teamusers.service.js";
/**
 * Controller for Team Users API operations
 */
/**
 * List team users
 */
async function listTeamusers(args) {
    const methodLogger = Logger.forContext("teamusers.controller.ts", "listTeamusers");
    methodLogger.debug("Getting Lokalise team users list...", args);
    try {
        // Validate team ID
        if (!args.teamId || typeof args.teamId !== "string") {
            throw new McpError("Team ID is required and must be a string.", ErrorType.API_ERROR);
        }
        // Validate pagination parameters
        if (args.limit !== undefined && (args.limit < 1 || args.limit > 100)) {
            throw new McpError("Invalid limit parameter. Must be between 1 and 100.", ErrorType.API_ERROR);
        }
        if (args.page !== undefined && args.page < 1) {
            throw new McpError("Invalid page parameter. Must be 1 or greater.", ErrorType.API_ERROR);
        }
        // Call service layer
        const result = await teamusersService.list(args);
        // Format response using the formatter
        const formattedContent = formatTeamusersList(result, args.teamId);
        methodLogger.debug("Team users list fetched successfully", {
            teamId: args.teamId,
            userCount: result.items?.length || 0,
        });
        return {
            content: formattedContent,
        };
    }
    catch (error) {
        throw handleControllerError(error, {
            source: "TeamusersController.listTeamusers",
            entityType: "TeamUsers",
            entityId: args.teamId,
            operation: "listing",
        });
    }
}
/**
 * Get details of a specific team user
 */
async function getTeamusers(args) {
    const methodLogger = Logger.forContext("teamusers.controller.ts", "getTeamusers");
    methodLogger.debug("Getting team user details...", args);
    try {
        // Validate inputs
        if (!args.teamId) {
            throw new McpError("Team ID is required.", ErrorType.API_ERROR);
        }
        if (!args.userId) {
            throw new McpError("User ID is required.", ErrorType.API_ERROR);
        }
        // Call service layer
        const result = await teamusersService.get(args);
        // Format response
        const formattedContent = formatTeamusersDetails(result);
        methodLogger.debug("Team user details fetched successfully", {
            teamId: args.teamId,
            userId: args.userId,
        });
        return {
            content: formattedContent,
        };
    }
    catch (error) {
        throw handleControllerError(error, {
            source: "TeamusersController.getTeamusers",
            entityType: "TeamUser",
            entityId: String(args.userId),
            operation: "retrieving",
        });
    }
}
/**
 * Update a team user's role
 */
async function updateTeamusers(args) {
    const methodLogger = Logger.forContext("teamusers.controller.ts", "updateTeamusers");
    methodLogger.debug("Updating team user...", args);
    try {
        // Validate inputs
        if (!args.teamId) {
            throw new McpError("Team ID is required.", ErrorType.API_ERROR);
        }
        if (!args.userId) {
            throw new McpError("User ID is required.", ErrorType.API_ERROR);
        }
        if (!args.role) {
            throw new McpError("Role is required.", ErrorType.API_ERROR);
        }
        // Call service layer
        const result = await teamusersService.update(args);
        // Format response
        const formattedContent = formatUpdateTeamusersResult(result);
        methodLogger.debug("Team user updated successfully", {
            teamId: args.teamId,
            userId: args.userId,
            newRole: args.role,
        });
        return {
            content: formattedContent,
        };
    }
    catch (error) {
        throw handleControllerError(error, {
            source: "TeamusersController.updateTeamusers",
            entityType: "TeamUser",
            entityId: String(args.userId),
            operation: "updating",
        });
    }
}
/**
 * Delete a team user
 */
async function deleteTeamusers(args) {
    const methodLogger = Logger.forContext("teamusers.controller.ts", "deleteTeamusers");
    methodLogger.debug("Deleting team user...", args);
    try {
        // Validate inputs
        if (!args.teamId) {
            throw new McpError("Team ID is required.", ErrorType.API_ERROR);
        }
        if (!args.userId) {
            throw new McpError("User ID is required.", ErrorType.API_ERROR);
        }
        // Call service layer
        const result = await teamusersService.delete(args);
        // Format response
        const formattedContent = formatDeleteTeamusersResult(result);
        methodLogger.debug("Team user deleted successfully", {
            teamId: args.teamId,
            userId: args.userId,
        });
        return {
            content: formattedContent,
        };
    }
    catch (error) {
        throw handleControllerError(error, {
            source: "TeamusersController.deleteTeamusers",
            entityType: "TeamUser",
            entityId: String(args.userId),
            operation: "deleting",
        });
    }
}
/**
 * Controller for Lokalise Team Users API operations
 */
const teamusersController = {
    listTeamusers,
    getTeamusers,
    updateTeamusers,
    deleteTeamusers,
};
export default teamusersController;