postgresai 0.14.0-dev.7 → 0.14.0-dev.71

package/lib/issues.ts

@@ -1,6 +1,15 @@
-import * as https from "https";
-import { URL } from "url";
-import { maskSecret, normalizeBaseUrl } from "./util";
+import { formatHttpError, maskSecret, normalizeBaseUrl } from "./util";
+
+/**
+ * Issue status constants.
+ * Used in updateIssue to change issue state.
+ */
+export const IssueStatus = {
+  /** Issue is open and active */
+  OPEN: 0,
+  /** Issue is closed/resolved */
+  CLOSED: 1,
+} as const;
 
 export interface IssueActionItem {
   id: string;
@@ -71,63 +80,38 @@ export async function fetchIssues(params: FetchIssuesParams): Promise<IssueListI
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
     const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
-    // eslint-disable-next-line no-console
     console.log(`Debug: Resolved API base URL: ${base}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: GET URL: ${url.toString()}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Auth scheme: access-token`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
   }
 
-  return new Promise((resolve, reject) => {
-    const req = https.request(
-      url,
-      {
-        method: "GET",
-        headers,
-      },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          if (debug) {
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response status: ${res.statusCode}`);
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
-          }
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-            try {
-              const parsed = JSON.parse(data) as IssueListItem[];
-              resolve(parsed);
-            } catch {
-              reject(new Error(`Failed to parse issues response: ${data}`));
-            }
-          } else {
-            let errMsg = `Failed to fetch issues: HTTP ${res.statusCode}`;
-            if (data) {
-              try {
-                const errObj = JSON.parse(data);
-                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
-              } catch {
-                errMsg += `\n${data}`;
-              }
-            }
-            reject(new Error(errMsg));
-          }
-        });
-      }
-    );
-
-    req.on("error", (err: Error) => reject(err));
-    req.end();
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
   });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as IssueListItem[];
+    } catch {
+      throw new Error(`Failed to parse issues response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to fetch issues", response.status, data));
+  }
 }
 
 
@@ -154,63 +138,38 @@ export async function fetchIssueComments(params: FetchIssueCommentsParams): Prom
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
     const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
-    // eslint-disable-next-line no-console
     console.log(`Debug: Resolved API base URL: ${base}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: GET URL: ${url.toString()}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Auth scheme: access-token`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
   }
 
-  return new Promise((resolve, reject) => {
-    const req = https.request(
-      url,
-      {
-        method: "GET",
-        headers,
-      },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          if (debug) {
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response status: ${res.statusCode}`);
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
-          }
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-            try {
-              const parsed = JSON.parse(data) as IssueComment[];
-              resolve(parsed);
-            } catch {
-              reject(new Error(`Failed to parse issue comments response: ${data}`));
-            }
-          } else {
-            let errMsg = `Failed to fetch issue comments: HTTP ${res.statusCode}`;
-            if (data) {
-              try {
-                const errObj = JSON.parse(data);
-                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
-              } catch {
-                errMsg += `\n${data}`;
-              }
-            }
-            reject(new Error(errMsg));
-          }
-        });
-      }
-    );
-
-    req.on("error", (err: Error) => reject(err));
-    req.end();
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
   });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as IssueComment[];
+    } catch {
+      throw new Error(`Failed to parse issue comments response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to fetch issue comments", response.status, data));
+  }
 }
 
 export interface FetchIssueParams {
@@ -239,67 +198,149 @@ export async function fetchIssue(params: FetchIssueParams): Promise<IssueDetail
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
     const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
-    // eslint-disable-next-line no-console
     console.log(`Debug: Resolved API base URL: ${base}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: GET URL: ${url.toString()}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Auth scheme: access-token`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
   }
 
-  return new Promise((resolve, reject) => {
-    const req = https.request(
-      url,
-      {
-        method: "GET",
-        headers,
-      },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          if (debug) {
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response status: ${res.statusCode}`);
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
-          }
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-            try {
-              const parsed = JSON.parse(data);
-              if (Array.isArray(parsed)) {
-                resolve((parsed[0] as IssueDetail) ?? null);
-              } else {
-                resolve(parsed as IssueDetail);
-              }
-            } catch {
-              reject(new Error(`Failed to parse issue response: ${data}`));
-            }
-          } else {
-            let errMsg = `Failed to fetch issue: HTTP ${res.statusCode}`;
-            if (data) {
-              try {
-                const errObj = JSON.parse(data);
-                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
-              } catch {
-                errMsg += `\n${data}`;
-              }
-            }
-            reject(new Error(errMsg));
-          }
-        });
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
+  });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      const parsed = JSON.parse(data);
+      if (Array.isArray(parsed)) {
+        return (parsed[0] as IssueDetail) ?? null;
+      } else {
+        return parsed as IssueDetail;
       }
-    );
+    } catch {
+      throw new Error(`Failed to parse issue response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to fetch issue", response.status, data));
+  }
+}
+
+export interface CreateIssueParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  title: string;
+  orgId: number;
+  description?: string;
+  projectId?: number;
+  labels?: string[];
+  debug?: boolean;
+}
+
+export interface CreatedIssue {
+  id: string;
+  title: string;
+  description: string | null;
+  created_at: string;
+  status: number;
+  project_id: number | null;
+  labels: string[] | null;
+}
+
+/**
+ * Create a new issue in the PostgresAI platform.
+ *
+ * @param params - The parameters for creating an issue
+ * @param params.apiKey - API key for authentication
+ * @param params.apiBaseUrl - Base URL for the API
+ * @param params.title - Issue title (required)
+ * @param params.orgId - Organization ID (required)
+ * @param params.description - Optional issue description
+ * @param params.projectId - Optional project ID to associate with
+ * @param params.labels - Optional array of label strings
+ * @param params.debug - Enable debug logging
+ * @returns The created issue object
+ * @throws Error if API key, title, or orgId is missing, or if the API call fails
+ */
+export async function createIssue(params: CreateIssueParams): Promise<CreatedIssue> {
+  const { apiKey, apiBaseUrl, title, orgId, description, projectId, labels, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!title) {
+    throw new Error("title is required");
+  }
+  if (typeof orgId !== "number") {
+    throw new Error("orgId is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_create`);
 
-    req.on("error", (err: Error) => reject(err));
-    req.end();
+  const bodyObj: Record<string, unknown> = {
+    title: title,
+    org_id: orgId,
+  };
+  if (description !== undefined) {
+    bodyObj.description = description;
+  }
+  if (projectId !== undefined) {
+    bodyObj.project_id = projectId;
+  }
+  if (labels && labels.length > 0) {
+    bodyObj.labels = labels;
+  }
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Connection": "close",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    console.log(`Debug: Auth scheme: access-token`);
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
   });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as CreatedIssue;
+    } catch {
+      throw new Error(`Failed to parse create issue response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to create issue", response.status, data));
+  }
 }
 
 export interface CreateIssueCommentParams {
@@ -339,67 +380,235 @@ export async function createIssueComment(params: CreateIssueCommentParams): Prom
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(body).toString(),
+    "Connection": "close",
   };
 
   if (debug) {
     const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
-    // eslint-disable-next-line no-console
     console.log(`Debug: Resolved API base URL: ${base}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: POST URL: ${url.toString()}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Auth scheme: access-token`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
-    // eslint-disable-next-line no-console
     console.log(`Debug: Request body: ${body}`);
   }
 
-  return new Promise((resolve, reject) => {
-    const req = https.request(
-      url,
-      {
-        method: "POST",
-        headers,
-      },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          if (debug) {
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response status: ${res.statusCode}`);
-            // eslint-disable-next-line no-console
-            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
-          }
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-            try {
-              const parsed = JSON.parse(data) as IssueComment;
-              resolve(parsed);
-            } catch {
-              reject(new Error(`Failed to parse create comment response: ${data}`));
-            }
-          } else {
-            let errMsg = `Failed to create issue comment: HTTP ${res.statusCode}`;
-            if (data) {
-              try {
-                const errObj = JSON.parse(data);
-                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
-              } catch {
-                errMsg += `\n${data}`;
-              }
-            }
-            reject(new Error(errMsg));
-          }
-        });
-      }
-    );
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
+  });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
 
-    req.on("error", (err: Error) => reject(err));
-    req.write(body);
-    req.end();
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as IssueComment;
+    } catch {
+      throw new Error(`Failed to parse create comment response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to create issue comment", response.status, data));
+  }
+}
+
+export interface UpdateIssueParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  issueId: string;
+  title?: string;
+  description?: string;
+  status?: number;
+  labels?: string[];
+  debug?: boolean;
+}
+
+export interface UpdatedIssue {
+  id: string;
+  title: string;
+  description: string | null;
+  status: number;
+  updated_at: string;
+  labels: string[] | null;
+}
+
+/**
+ * Update an existing issue in the PostgresAI platform.
+ *
+ * @param params - The parameters for updating an issue
+ * @param params.apiKey - API key for authentication
+ * @param params.apiBaseUrl - Base URL for the API
+ * @param params.issueId - ID of the issue to update (required)
+ * @param params.title - New title (optional)
+ * @param params.description - New description (optional)
+ * @param params.status - New status: 0 = open, 1 = closed (optional)
+ * @param params.labels - New labels array (optional, replaces existing)
+ * @param params.debug - Enable debug logging
+ * @returns The updated issue object
+ * @throws Error if API key or issueId is missing, if no fields to update are provided, or if the API call fails
+ */
+export async function updateIssue(params: UpdateIssueParams): Promise<UpdatedIssue> {
+  const { apiKey, apiBaseUrl, issueId, title, description, status, labels, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!issueId) {
+    throw new Error("issueId is required");
+  }
+  if (title === undefined && description === undefined && status === undefined && labels === undefined) {
+    throw new Error("At least one field to update is required (title, description, status, or labels)");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_update`);
+
+  // Prod RPC expects p_* argument names (see OpenAPI at /api/general/).
+  const bodyObj: Record<string, unknown> = {
+    p_id: issueId,
+  };
+  if (title !== undefined) {
+    bodyObj.p_title = title;
+  }
+  if (description !== undefined) {
+    bodyObj.p_description = description;
+  }
+  if (status !== undefined) {
+    bodyObj.p_status = status;
+  }
+  if (labels !== undefined) {
+    bodyObj.p_labels = labels;
+  }
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Connection": "close",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    console.log(`Debug: Auth scheme: access-token`);
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
   });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as UpdatedIssue;
+    } catch {
+      throw new Error(`Failed to parse update issue response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to update issue", response.status, data));
+  }
+}
+
+export interface UpdateIssueCommentParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  commentId: string;
+  content: string;
+  debug?: boolean;
+}
+
+export interface UpdatedIssueComment {
+  id: string;
+  issue_id: string;
+  content: string;
+  updated_at: string;
 }
 
+/**
+ * Update an existing issue comment in the PostgresAI platform.
+ *
+ * @param params - The parameters for updating a comment
+ * @param params.apiKey - API key for authentication
+ * @param params.apiBaseUrl - Base URL for the API
+ * @param params.commentId - ID of the comment to update (required)
+ * @param params.content - New comment content (required)
+ * @param params.debug - Enable debug logging
+ * @returns The updated comment object
+ * @throws Error if API key, commentId, or content is missing, or if the API call fails
+ */
+export async function updateIssueComment(params: UpdateIssueCommentParams): Promise<UpdatedIssueComment> {
+  const { apiKey, apiBaseUrl, commentId, content, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!commentId) {
+    throw new Error("commentId is required");
+  }
+  if (!content) {
+    throw new Error("content is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_comment_update`);
+
+  const bodyObj: Record<string, unknown> = {
+    // Prod RPC expects p_* argument names (see OpenAPI at /api/general/).
+    p_id: commentId,
+    p_content: content,
+  };
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Connection": "close",
+  };
 
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    console.log(`Debug: Auth scheme: access-token`);
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
+  });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as UpdatedIssueComment;
+    } catch {
+      throw new Error(`Failed to parse update comment response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to update issue comment", response.status, data));
+  }
+}