@goparrot/franchise-mcp-server/dist/src/dashboard/services/user.js

MCP Server for Franchise API

import { dashboardBaseUrl, makeRequest } from '../../common/index.js';
/**
 * Method information for dashboard user endpoints
 */
export const UserMethods = {
    create: {
        description: 'Create a new user',
        method: 'post',
        path: '/users-v2/api/v1/users',
        pathParams: [],
        queryParams: [],
        requestType: 'CreateUserRequest',
        isMultipart: false,
        originalName: 'create',
        isWrite: true,
        permissions: [],
    },
    findOne: {
        description: 'Get user by UUID',
        method: 'get',
        path: '/users-v2/api/v1/users/{uuid}',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'User UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'FindUserRequest',
        isMultipart: false,
        originalName: 'findOne',
        isWrite: false,
        permissions: ['user-v2:api:read'],
    },
    delete: {
        description: 'Delete user by UUID',
        method: 'delete',
        path: '/users-v2/api/v1/users/{uuid}',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'User UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'DeleteUserRequest',
        isMultipart: false,
        originalName: 'delete',
        isWrite: true,
        permissions: ['user-v2:api:delete'],
    },
    deleteInvite: {
        description: 'Delete franchise user invite',
        method: 'delete',
        path: '/users-v2/api/v1/users/{uuid}/franchise-invite',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'User UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'DeleteFranchiseInviteRequest',
        isMultipart: false,
        originalName: 'deleteInvite',
        isWrite: true,
        permissions: ['user-v2:api:delete'],
    },
    list: {
        description: 'List users with filters',
        method: 'get',
        path: '/users-v2/api/v1/users',
        pathParams: [],
        queryParams: [],
        requestType: 'ListUsersRequest',
        isMultipart: false,
        originalName: 'list',
        isWrite: false,
        permissions: [],
    },
    patch: {
        description: 'Update user by UUID',
        method: 'patch',
        path: '/users-v2/api/v1/users/{uuid}',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'User UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'PatchUserRequest',
        isMultipart: false,
        originalName: 'patch',
        isWrite: true,
        permissions: ['user-v2:api:update'],
    },
    invite: {
        description: 'Invite a new user',
        method: 'post',
        path: '/users-v2/api/v1/users/invite',
        pathParams: [],
        queryParams: [],
        requestType: 'InviteUserRequest',
        isMultipart: false,
        originalName: 'invite',
        isWrite: true,
        permissions: ['user-v2:api:create'],
    },
    inviteConfirm: {
        description: 'Confirm user invitation',
        method: 'post',
        path: '/users-v2/api/v1/users/invite-confirm',
        pathParams: [],
        queryParams: [],
        requestType: 'InviteConfirmRequest',
        isMultipart: false,
        originalName: 'inviteConfirm',
        isWrite: true,
        permissions: [],
    },
    inviteFranchise: {
        description: 'Invite franchise users',
        method: 'post',
        path: '/users-v2/api/v1/users/franchise/invite',
        pathParams: [],
        queryParams: [],
        requestType: 'InviteFranchiseUsersRequest',
        isMultipart: false,
        originalName: 'inviteFranchise',
        isWrite: true,
        permissions: ['user-v2:api:create'],
    },
    inviteFranchiseConfirm: {
        description: 'Confirm franchise user invitation',
        method: 'post',
        path: '/users-v2/api/v1/users/franchise/invite-confirm',
        pathParams: [],
        queryParams: [],
        requestType: 'InviteFranchiseConfirmRequest',
        isMultipart: false,
        originalName: 'inviteFranchiseConfirm',
        isWrite: true,
        permissions: [],
    },
    franchiseConnectOrganization: {
        description: 'Connect franchise organization for user',
        method: 'post',
        path: '/users-v2/api/v1/users/{uuid}/franchise/connect',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'User UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'FranchiseConnectOrganizationRequest',
        isMultipart: false,
        originalName: 'franchiseConnectOrganization',
        isWrite: true,
        permissions: ['store:api:update', 'store:api:create'],
    },
    franchiseConnectOrganizationConfirm: {
        description: 'Confirm franchise organization connection',
        method: 'post',
        path: '/users-v2/api/v1/users/{uuid}/franchise/confirm',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'User UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'FranchiseConnectOrganizationConfirmRequest',
        isMultipart: false,
        originalName: 'franchiseConnectOrganizationConfirm',
        isWrite: true,
        permissions: ['store:api:update', 'store:api:create'],
    },
};
/**
 * Handlers for dashboard user endpoints
 */
export const UserHandlers = {
    create: async (accessToken, args) => {
        return makeRequest(UserMethods.create, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    findOne: async (accessToken, args) => {
        return makeRequest(UserMethods.findOne, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    delete: async (accessToken, args) => {
        return makeRequest(UserMethods.delete, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    deleteInvite: async (accessToken, args) => {
        return makeRequest(UserMethods.deleteInvite, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    list: async (accessToken, args) => {
        return makeRequest(UserMethods.list, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    patch: async (accessToken, args) => {
        return makeRequest(UserMethods.patch, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    invite: async (accessToken, args) => {
        return makeRequest(UserMethods.invite, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    inviteConfirm: async (accessToken, args) => {
        return makeRequest(UserMethods.inviteConfirm, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    inviteFranchise: async (accessToken, args) => {
        return makeRequest(UserMethods.inviteFranchise, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    inviteFranchiseConfirm: async (accessToken, args) => {
        return makeRequest(UserMethods.inviteFranchiseConfirm, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    franchiseConnectOrganization: async (accessToken, args) => {
        return makeRequest(UserMethods.franchiseConnectOrganization, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    franchiseConnectOrganizationConfirm: async (accessToken, args) => {
        return makeRequest(UserMethods.franchiseConnectOrganizationConfirm, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
};