@credal/actions 0.2.147 → 0.2.149

package/dist/actions/providers/jira/createJiraTicket.js

@@ -8,61 +8,51 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { axiosClient } from "../../util/axiosClient.js";
-import { getUserAccountIdFromEmail, getRequestTypeCustomFieldId } from "./utils.js";
+import { resolveAccountIdIfEmail, resolveRequestTypeField, getJiraApiConfig, getErrorMessage } from "./utils.js";
 const createJiraTicket = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { authToken, cloudId, baseUrl } = authParams;
-    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/`;
-    if (!cloudId || !authToken) {
-        throw new Error("Valid Cloud ID and auth token are required to comment on Jira ticket");
+    const { authToken } = authParams;
+    const { apiUrl, browseUrl, strategy } = getJiraApiConfig(authParams);
+    // authToken is guaranteed to exist after getJiraApiConfig succeeds
+    if (!authToken) {
+        throw new Error("Auth token is required");
     }
-    // If assignee is an email, look up the account ID
-    let reporterId = null;
-    if (params.reporter && typeof params.reporter === "string" && params.reporter.includes("@") && authToken) {
-        reporterId = yield getUserAccountIdFromEmail(params.reporter, apiUrl, authToken);
-    }
-    // If assignee is an email, look up the account ID
-    let assigneeId = null;
-    if (params.assignee && typeof params.assignee === "string" && params.assignee.includes("@") && authToken) {
-        assigneeId = yield getUserAccountIdFromEmail(params.assignee, apiUrl, authToken);
-    }
-    // If request type is provided, find the custom field ID and prepare the value
-    const requestTypeField = {};
-    if (params.requestTypeId && authToken) {
-        const requestTypeFieldId = yield getRequestTypeCustomFieldId(params.projectKey, apiUrl, authToken);
-        if (requestTypeFieldId) {
-            requestTypeField[requestTypeFieldId] = params.requestTypeId;
-        }
-    }
-    const description = {
-        type: "doc",
-        version: 1,
-        content: [
-            {
-                type: "paragraph",
-                content: [
-                    {
-                        type: "text",
-                        text: params.description,
-                    },
-                ],
-            },
-        ],
-    };
+    const [reporterId, assigneeId] = yield Promise.all([
+        resolveAccountIdIfEmail(params.reporter, apiUrl, authToken, strategy),
+        resolveAccountIdIfEmail(params.assignee, apiUrl, authToken, strategy),
+    ]);
+    const { field: requestTypeField, message: partialUpdateMessage } = yield resolveRequestTypeField(params.requestTypeId, params.projectKey, apiUrl, authToken);
+    const reporterAssignment = strategy.formatUserAssignment(reporterId);
+    const assigneeAssignment = strategy.formatUserAssignment(assigneeId);
     const payload = {
         fields: Object.assign(Object.assign(Object.assign(Object.assign({ project: {
                 key: params.projectKey,
-            }, summary: params.summary, description: description, issuetype: {
+            }, summary: params.summary, description: strategy.formatText(params.description), issuetype: {
                 name: params.issueType,
-            } }, (reporterId ? { reporter: { id: reporterId } } : {})), (assigneeId ? { assignee: { id: assigneeId } } : {})), requestTypeField), (params.customFields ? params.customFields : {})),
-    };
-    const response = yield axiosClient.post(`${apiUrl}/issue`, payload, {
-        headers: {
-            Authorization: `Bearer ${authToken}`,
-            Accept: "application/json",
-        },
-    });
-    return {
-        ticketUrl: `${baseUrl}/browse/${response.data.key}`,
+            } }, (reporterAssignment && { reporter: reporterAssignment })), (assigneeAssignment && { assignee: assigneeAssignment })), (Object.keys(requestTypeField).length > 0 && requestTypeField)), (params.customFields && params.customFields)),
     };
+    try {
+        const response = yield axiosClient.post(`${apiUrl}/issue`, payload, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/json",
+            },
+        });
+        const ticketKey = response.data.key;
+        if (!ticketKey) {
+            // Check if we got HTML instead of JSON (common when auth fails)
+            if (typeof response.data === "string" && response.data.includes("<!DOCTYPE html>")) {
+                throw new Error("Received HTML response instead of JSON - this usually indicates authentication failed or the server redirected to a login page");
+            }
+            console.error("No ticket key in response:", JSON.stringify(response.data, null, 2));
+            throw new Error("Failed to get ticket key from Jira response");
+        }
+        return Object.assign({ success: true, ticketUrl: `${browseUrl}/browse/${ticketKey}` }, (partialUpdateMessage && { error: partialUpdateMessage }));
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: getErrorMessage(error),
+        };
+    }
 });
 export default createJiraTicket;

package/dist/actions/providers/jira/getJiraIssuesByQuery.js

@@ -7,13 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ApiError, axiosClient } from "../../util/axiosClient.js";
+import { axiosClient } from "../../util/axiosClient.js";
+import { getJiraApiConfig, getErrorMessage } from "./utils.js";
 const DEFAULT_LIMIT = 100;
 const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { authToken, cloudId, baseUrl } = authParams;
+    const { authToken } = authParams;
     const { query, limit } = params;
-    if (!cloudId || !authToken || !baseUrl) {
-        throw new Error("Valid Cloud ID, base URL, and auth token are required to comment on Jira ticket");
+    const { apiUrl, browseUrl, strategy } = getJiraApiConfig(authParams);
+    if (!authToken) {
+        throw new Error("Auth token is required");
     }
     const queryParams = new URLSearchParams();
     queryParams.set("jql", query);
@@ -38,9 +40,10 @@ const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* (
         "aggregatetimeoriginalestimate",
     ];
     queryParams.set("fields", fields.join(","));
-    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/search/jql?${queryParams.toString()}`;
+    const searchEndpoint = strategy.getSearchEndpoint();
+    const fullApiUrl = `${apiUrl}${searchEndpoint}?${queryParams.toString()}`;
     try {
-        const response = yield axiosClient.get(apiUrl, {
+        const response = yield axiosClient.get(fullApiUrl, {
             headers: {
                 Authorization: `Bearer ${authToken}`,
                 Accept: "application/json",
@@ -49,39 +52,41 @@ const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* (
         return {
             success: true,
             results: response.data.issues.map(issue => {
-                var _a, _b, _c, _d;
-                return ({
-                    name: issue.key,
-                    url: `${baseUrl}/browse/${issue.key}`,
+                const { id, key, fields } = issue;
+                const { summary, description, project, issuetype, status, assignee, reporter, creator, created, updated, resolution, duedate, } = fields;
+                const ticketUrl = `${browseUrl}/browse/${key}`;
+                return {
+                    name: key,
+                    url: ticketUrl,
                     contents: {
-                        id: issue.id,
-                        key: issue.key,
-                        summary: issue.fields.summary,
-                        description: extractPlainText(issue.fields.description),
+                        id,
+                        key,
+                        summary,
+                        description: extractPlainText(description),
                         project: {
-                            id: issue.fields.project.id,
-                            key: issue.fields.project.key,
-                            name: issue.fields.project.name,
+                            id: project.id,
+                            key: project.key,
+                            name: project.name,
                         },
                         issueType: {
-                            id: issue.fields.issuetype.id,
-                            name: issue.fields.issuetype.name,
+                            id: issuetype.id,
+                            name: issuetype.name,
                         },
                         status: {
-                            id: issue.fields.status.id,
-                            name: issue.fields.status.name,
-                            category: issue.fields.status.statusCategory.name,
+                            id: status.id,
+                            name: status.name,
+                            category: status.statusCategory.name,
                         },
-                        assignee: ((_a = issue.fields.assignee) === null || _a === void 0 ? void 0 : _a.emailAddress) || null,
-                        reporter: ((_b = issue.fields.reporter) === null || _b === void 0 ? void 0 : _b.emailAddress) || null,
-                        creator: ((_c = issue.fields.creator) === null || _c === void 0 ? void 0 : _c.emailAddress) || null,
-                        created: issue.fields.created,
-                        updated: issue.fields.updated,
-                        resolution: ((_d = issue.fields.resolution) === null || _d === void 0 ? void 0 : _d.name) || null,
-                        dueDate: issue.fields.duedate || null,
-                        url: `${baseUrl}/browse/${issue.key}`,
+                        assignee: (assignee === null || assignee === void 0 ? void 0 : assignee.emailAddress) || null,
+                        reporter: (reporter === null || reporter === void 0 ? void 0 : reporter.emailAddress) || null,
+                        creator: (creator === null || creator === void 0 ? void 0 : creator.emailAddress) || null,
+                        created,
+                        updated,
+                        resolution: (resolution === null || resolution === void 0 ? void 0 : resolution.name) || null,
+                        dueDate: duedate || null,
+                        url: ticketUrl,
                     },
-                });
+                };
             }),
         };
     }
@@ -89,11 +94,7 @@ const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* (
         console.error("Error retrieving Jira issues:", error);
         return {
             success: false,
-            error: error instanceof ApiError
-                ? error.data.length > 0
-                    ? error.data[0].message
-                    : error.message
-                : "An unknown error occurred",
+            error: getErrorMessage(error),
         };
     }
 });

package/dist/actions/providers/jira/getJiraTicketDetails.js

@@ -8,16 +8,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { axiosClient } from "../../util/axiosClient.js";
+import { getJiraApiConfig, getErrorMessage } from "./utils.js";
 // https://developer.atlassian.com/cloud/jira/platform/rest/v2/api-group-issues/#api-rest-api-2-issue-issueidorkey-get
 const getJiraTicketDetails = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { authToken, cloudId, baseUrl } = authParams;
+    const { authToken, baseUrl } = authParams;
     const { issueId } = params;
-    if (!cloudId || !authToken || !baseUrl) {
+    const { apiUrl } = getJiraApiConfig(authParams);
+    if (!authToken || !baseUrl) {
         throw new Error("Valid Cloud ID, base URL, and auth token are required to get Jira ticket details");
     }
-    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${issueId}`;
+    const fullApiUrl = `${apiUrl}/issue/${issueId}`;
     try {
-        const response = yield axiosClient.get(apiUrl, {
+        const response = yield axiosClient.get(fullApiUrl, {
             headers: {
                 Authorization: `Bearer ${authToken}`,
                 Accept: "application/json",
@@ -38,7 +40,7 @@ const getJiraTicketDetails = (_a) => __awaiter(void 0, [_a], void 0, function* (
         console.error("Error retrieving Jira ticket details: ", error);
         return {
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: getErrorMessage(error),
         };
     }
 });

package/dist/actions/providers/jira/getJiraTicketHistory.js

@@ -8,31 +8,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { axiosClient } from "../../util/axiosClient.js";
+import { getJiraApiConfig, getErrorMessage } from "./utils.js";
 const getJiraTicketHistory = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    var _b;
-    const { authToken, cloudId } = authParams;
+    const { authToken } = authParams;
     const { issueId } = params;
-    if (!cloudId || !authToken) {
-        throw new Error("Valid Cloud ID and auth token are required to comment on Jira ticket");
+    const { apiUrl, strategy } = getJiraApiConfig(authParams);
+    if (!authToken) {
+        throw new Error("Auth token is required");
     }
-    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${issueId}/changelog`;
+    const fullApiUrl = `${apiUrl}${strategy.getHistoryEndpoint(issueId)}`;
     try {
-        const response = yield axiosClient.get(apiUrl, {
+        const response = yield axiosClient.get(fullApiUrl, {
             headers: {
                 Authorization: `Bearer ${authToken}`,
                 Accept: "application/json",
             },
         });
+        const historyData = strategy.parseHistoryResponse(response);
         return {
             success: true,
-            history: (_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.values,
+            history: historyData,
         };
     }
     catch (error) {
         console.error("Error retrieving Jira ticket history: ", error);
         return {
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: getErrorMessage(error),
         };
     }
 });

package/dist/actions/providers/jira/updateJiraTicketDetails.js

@@ -8,56 +8,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { axiosClient } from "../../util/axiosClient.js";
-import { getRequestTypeCustomFieldId } from "./utils.js";
+import { resolveRequestTypeField, getJiraApiConfig, getErrorMessage } from "./utils.js";
 const updateJiraTicketDetails = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { authToken, cloudId, baseUrl } = authParams;
-    const { issueId, summary, description, customFields, requestTypeId } = params;
-    if (!cloudId || !authToken) {
-        throw new Error("Valid Cloud ID and auth token are required to comment on Jira ticket");
-    }
-    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${issueId}`;
-    const formattedDescription = description
-        ? {
-            type: "doc",
-            version: 1,
-            content: [
-                {
-                    type: "paragraph",
-                    content: [
-                        {
-                            type: "text",
-                            text: description,
-                        },
-                    ],
-                },
-            ],
-        }
-        : undefined;
-    // If request type is provided, find the custom field ID and prepare the value
-    const requestTypeField = {};
-    if (requestTypeId && authToken) {
-        const requestTypeFieldId = yield getRequestTypeCustomFieldId(params.projectKey, `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3`, authToken);
-        if (requestTypeFieldId) {
-            requestTypeField[requestTypeFieldId] = requestTypeId;
-        }
+    const { authToken } = authParams;
+    const { issueId, summary, description, customFields, requestTypeId, projectKey } = params;
+    const { apiUrl, browseUrl, strategy } = getJiraApiConfig(authParams);
+    if (!authToken) {
+        throw new Error("Auth token is required");
     }
+    const fullApiUrl = `${apiUrl}/issue/${issueId}`;
+    const formattedDescription = description ? strategy.formatText(description) : undefined;
+    const { field: requestTypeField, message: partialUpdateMessage } = yield resolveRequestTypeField(requestTypeId, projectKey, apiUrl, authToken);
     const payload = {
-        fields: Object.assign(Object.assign(Object.assign(Object.assign({}, (summary && { summary })), (formattedDescription && { description: formattedDescription })), requestTypeField), (customFields && Object.assign({}, customFields))),
+        fields: Object.assign(Object.assign(Object.assign(Object.assign({}, (summary && { summary })), (formattedDescription && { description: formattedDescription })), (Object.keys(requestTypeField).length > 0 && requestTypeField)), (customFields && customFields)),
     };
     try {
-        yield axiosClient.put(apiUrl, payload, {
+        yield axiosClient.put(fullApiUrl, payload, {
             headers: {
                 Authorization: `Bearer ${authToken}`,
                 Accept: "application/json",
             },
         });
-        return {
-            ticketUrl: `${baseUrl}/browse/${issueId}`,
-        };
+        return Object.assign({ success: true, ticketUrl: `${browseUrl}/browse/${issueId}` }, (partialUpdateMessage && { error: partialUpdateMessage }));
     }
     catch (error) {
         console.error("Error updating Jira ticket:", error);
-        throw new Error(error instanceof Error ? error.message : "Unknown error");
+        return {
+            success: false,
+            error: getErrorMessage(error),
+        };
     }
 });
 export default updateJiraTicketDetails;

package/dist/actions/providers/jira/updateJiraTicketStatus.js

@@ -8,13 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { axiosClient } from "../../util/axiosClient.js";
+import { getJiraApiConfig, getErrorMessage } from "./utils.js";
 const updateJiraTicketStatus = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { authToken, cloudId, baseUrl } = authParams;
-    if (!cloudId || !authToken) {
-        throw new Error("Valid Cloud ID and auth token are required to comment on Jira ticket");
+    const { authToken } = authParams;
+    const { apiUrl, browseUrl } = getJiraApiConfig(authParams);
+    if (!authToken) {
+        throw new Error("Auth token is required");
     }
     const { issueId, status } = params;
-    const transitionsUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${issueId}/transitions`;
+    const transitionsUrl = `${apiUrl}/issue/${issueId}/transitions`;
     try {
         // API takes transition ID, so fetch available transitions the find ID of transition that matches given status name
         const transitionsResponse = yield axiosClient.get(transitionsUrl, {
@@ -41,14 +43,14 @@ const updateJiraTicketStatus = (_a) => __awaiter(void 0, [_a], void 0, function*
         });
         return {
             success: true,
-            ticketUrl: `${baseUrl}/browse/${issueId}`,
+            ticketUrl: `${browseUrl}/browse/${issueId}`,
         };
     }
     catch (error) {
         console.error("Error updating Jira ticket status: ", error);
         return {
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: getErrorMessage(error),
         };
     }
 });

package/dist/actions/providers/jira/utils.d.ts

@@ -1,2 +1,55 @@
-export declare function getUserAccountIdFromEmail(email: string, apiUrl: string, authToken: string): Promise<string | null>;
-export declare function getRequestTypeCustomFieldId(projectKey: string, apiUrl: string, authToken: string): Promise<string | null>;
+export interface JiraApiConfig {
+    apiUrl: string;
+    browseUrl: string;
+    isDataCenter: boolean;
+    strategy: JiraPlatformStrategy;
+}
+export interface JiraServiceDeskApiConfig {
+    serviceDeskApiUrl: string;
+    browseUrl: string;
+    isDataCenter: boolean;
+}
+interface JiraHistoryResponse {
+    data?: {
+        values?: unknown[];
+        changelog?: {
+            histories?: unknown[];
+        };
+    };
+}
+export interface JiraPlatformStrategy {
+    formatText(text: string): string | object;
+    formatUser(userId: string | null): {
+        [key: string]: string;
+    } | null;
+    formatUserAssignment(userId: string | null): {
+        id?: string;
+        name?: string;
+    } | null;
+    getUserSearchParam(): string;
+    getSearchEndpoint(): string;
+    getHistoryEndpoint(issueId: string): string;
+    parseHistoryResponse(response: JiraHistoryResponse): unknown[] | undefined;
+}
+export declare function getPlatformStrategy(isDataCenter: boolean): JiraPlatformStrategy;
+export declare function getJiraApiConfig(authParams: {
+    cloudId?: string;
+    baseUrl?: string;
+    authToken?: string;
+    provider?: string;
+}): JiraApiConfig;
+export declare function isEmail(value: string | undefined): value is string;
+export declare function resolveAccountIdIfEmail(value: string | undefined, apiUrl: string, authToken: string, strategy: JiraPlatformStrategy): Promise<string | null>;
+export declare function getUserAccountIdFromEmail(email: string, apiUrl: string, authToken: string, strategy: JiraPlatformStrategy): Promise<string | null>;
+export declare function getErrorMessage(error: unknown): string;
+export declare function resolveRequestTypeField(requestTypeId: string | undefined, projectKey: string | undefined, apiUrl: string, authToken: string): Promise<{
+    field: {
+        [key: string]: string;
+    };
+    message?: string;
+}>;
+export declare function getRequestTypeCustomFieldId(projectKey: string, apiUrl: string, authToken: string): Promise<{
+    fieldId: string | null;
+    message?: string;
+}>;
+export {};

package/dist/actions/providers/jira/utils.js

@@ -8,17 +8,111 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { axiosClient } from "../../util/axiosClient.js";
-export function getUserAccountIdFromEmail(email, apiUrl, authToken) {
+const cloudStrategy = {
+    formatText: (text) => ({
+        type: "doc",
+        version: 1,
+        content: [
+            {
+                type: "paragraph",
+                content: [
+                    {
+                        type: "text",
+                        text: text,
+                    },
+                ],
+            },
+        ],
+    }),
+    formatUser: (userId) => {
+        if (!userId)
+            return null;
+        return { accountId: userId };
+    },
+    formatUserAssignment: (userId) => {
+        if (!userId)
+            return null;
+        return { id: userId };
+    },
+    getUserSearchParam: () => "query",
+    getSearchEndpoint: () => "/search/jql",
+    getHistoryEndpoint: (issueId) => `/issue/${issueId}/changelog`,
+    parseHistoryResponse: (response) => { var _a; return (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.values; },
+};
+const dataCenterStrategy = {
+    formatText: (text) => text,
+    formatUser: (userId) => {
+        if (!userId)
+            return null;
+        return { name: userId };
+    },
+    formatUserAssignment: (userId) => {
+        if (!userId)
+            return null;
+        return { name: userId };
+    },
+    getUserSearchParam: () => "username",
+    getSearchEndpoint: () => "/search",
+    getHistoryEndpoint: (issueId) => `/issue/${issueId}?expand=changelog`,
+    parseHistoryResponse: (response) => { var _a, _b; return (_b = (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.changelog) === null || _b === void 0 ? void 0 : _b.histories; },
+};
+export function getPlatformStrategy(isDataCenter) {
+    return isDataCenter ? dataCenterStrategy : cloudStrategy;
+}
+export function getJiraApiConfig(authParams) {
+    const { cloudId, baseUrl, authToken, provider } = authParams;
+    if (!authToken) {
+        throw new Error("Valid auth token is required");
+    }
+    const isDataCenter = provider === "jiraDataCenter";
+    const strategy = getPlatformStrategy(isDataCenter);
+    if (isDataCenter) {
+        if (!baseUrl) {
+            throw new Error("Valid base URL is required for Jira Data Center");
+        }
+        const trimmedUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+        return {
+            apiUrl: `${trimmedUrl}/rest/api/2`,
+            browseUrl: trimmedUrl,
+            isDataCenter: true,
+            strategy,
+        };
+    }
+    if (!cloudId) {
+        throw new Error("Valid Cloud ID is required for Jira Cloud");
+    }
+    return {
+        apiUrl: `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3`,
+        browseUrl: baseUrl || `https://${cloudId}.atlassian.net`,
+        isDataCenter: false,
+        strategy,
+    };
+}
+export function isEmail(value) {
+    return typeof value === "string" && value.includes("@");
+}
+export function resolveAccountIdIfEmail(value, apiUrl, authToken, strategy) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return isEmail(value) ? getUserAccountIdFromEmail(value, apiUrl, authToken, strategy) : null;
+    });
+}
+export function getUserAccountIdFromEmail(email, apiUrl, authToken, strategy) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const response = yield axiosClient.get(`${apiUrl}/user/search?query=${encodeURIComponent(email)}`, {
+            const searchParam = strategy.getUserSearchParam();
+            const response = yield axiosClient.get(`${apiUrl}/user/search?${searchParam}=${encodeURIComponent(email)}`, {
                 headers: {
                     Authorization: `Bearer ${authToken}`,
                     Accept: "application/json",
                 },
             });
             if (response.data && response.data.length > 0) {
-                return response.data[0].accountId;
+                const user = response.data[0];
+                // Use strategy to determine which field to use
+                const userId = strategy === dataCenterStrategy ? user.name || user.key : user.accountId;
+                if (!userId)
+                    return null;
+                return userId;
             }
             return null;
         }
@@ -29,8 +123,30 @@ export function getUserAccountIdFromEmail(email, apiUrl, authToken) {
         }
     });
 }
+export function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export function resolveRequestTypeField(requestTypeId, projectKey, apiUrl, authToken) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!requestTypeId || !projectKey) {
+            return { field: {} };
+        }
+        const result = yield getRequestTypeCustomFieldId(projectKey, apiUrl, authToken);
+        const field = {};
+        if (result.fieldId) {
+            field[result.fieldId] = requestTypeId;
+        }
+        return {
+            field,
+            message: result.message,
+        };
+    });
+}
 export function getRequestTypeCustomFieldId(projectKey, apiUrl, authToken) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
             const response = yield axiosClient.get(`${apiUrl}/issue/createmeta?projectKeys=${projectKey}&expand=projects.issuetypes.fields`, {
                 headers: {
@@ -40,12 +156,12 @@ export function getRequestTypeCustomFieldId(projectKey, apiUrl, authToken) {
             });
             const projects = response.data.projects;
             if (!projects || projects.length === 0) {
-                return null;
+                return { fieldId: null };
             }
             const project = projects[0];
             const issueTypes = project.issuetypes;
             if (!issueTypes || issueTypes.length === 0) {
-                return null;
+                return { fieldId: null };
             }
             for (const issueType of issueTypes) {
                 const fields = issueType.fields;
@@ -54,18 +170,22 @@ export function getRequestTypeCustomFieldId(projectKey, apiUrl, authToken) {
                         if (fieldData && typeof fieldData === "object" && "name" in fieldData) {
                             const fieldInfo = fieldData;
                             if (fieldInfo.name === "Request Type") {
-                                return fieldId;
+                                return { fieldId };
                             }
                         }
                     }
                 }
             }
-            return null;
+            return { fieldId: null };
         }
         catch (error) {
             const axiosError = error;
-            console.error("Error finding Request Type custom field:", axiosError.message);
-            return null;
+            if (((_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                return { fieldId: null, message: "Request Type field not found (optional for Service Desk), skipping..." };
+            }
+            else {
+                return { fieldId: null, message: `Error finding Request Type custom field: ${axiosError.message}` };
+            }
         }
     });
 }