@upstart.gg/sdk 0.0.129 → 0.0.131

package/src/shared/datarecords/external/google/sheets/client.ts

@@ -0,0 +1,112 @@
+interface ApiResponse<T> {
+  success: boolean;
+  data: T;
+  status: number;
+  headers: Headers;
+}
+
+class GoogleDriveClient {
+  private accessToken: string;
+
+  constructor(accessToken: string) {
+    this.accessToken = accessToken;
+  }
+
+  async callDriveApi<T>(
+    endpoint: string,
+    method: "GET" | "POST" | "PUT" | "PATCH" = "GET",
+    body?: unknown,
+  ): Promise<ApiResponse<T>> {
+    // Handle binary data for uploads
+    const isBinaryUpload = body instanceof ArrayBuffer || body instanceof Uint8Array;
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.accessToken}`,
+    };
+
+    if (!isBinaryUpload) {
+      headers["Content-Type"] = "application/json";
+    } else {
+      headers["Content-Type"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    }
+
+    const response = await fetch(endpoint, {
+      method,
+      headers,
+      body: isBinaryUpload ? (body as BodyInit) : body ? JSON.stringify(body) : undefined,
+    });
+
+    // Handle CSV responses
+    if (endpoint.includes("export") && endpoint.includes("mimeType=text/csv")) {
+      const csvText = await response.text();
+      return {
+        success: response.ok,
+        data: csvText as T,
+        status: response.status,
+        headers: response.headers,
+      };
+    }
+
+    // Handle binary responses (like XLSX downloads) - keeping for compatibility
+    if (
+      endpoint.includes("export") &&
+      endpoint.includes("mimeType=application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+    ) {
+      const arrayBuffer = await response.arrayBuffer();
+      return {
+        success: response.ok,
+        data: arrayBuffer as T,
+        status: response.status,
+        headers: response.headers,
+      };
+    }
+
+    // Handle upload responses which might not be JSON
+    if (endpoint.includes("upload/") && response.ok) {
+      // For successful uploads, try to parse JSON, but fallback gracefully
+      try {
+        const data = await response.json();
+        return {
+          success: response.ok,
+          data,
+          status: response.status,
+          headers: response.headers,
+        };
+      } catch {
+        // If JSON parsing fails but response is ok, return success
+        return {
+          success: true,
+          data: { message: "Upload successful" } as T,
+          status: response.status,
+          headers: response.headers,
+        };
+      }
+    }
+
+    // Handle error responses that might be HTML
+    if (!response.ok) {
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("text/html")) {
+        const errorText = await response.text();
+        return {
+          success: false,
+          data: { error: "HTML error response", details: errorText.substring(0, 200) } as T,
+          status: response.status,
+          headers: response.headers,
+        };
+      }
+    }
+
+    const data = await response.json();
+
+    return {
+      success: response.ok,
+      data,
+      status: response.status,
+      headers: response.headers,
+    };
+  }
+}
+
+export default function getClient(accessToken: string): GoogleDriveClient {
+  return new GoogleDriveClient(accessToken);
+}

package/src/shared/datarecords/external/google/sheets/handler.ts

@@ -0,0 +1,253 @@
+import type { TObject, TProperties } from "@sinclair/typebox";
+import getClient from "./client";
+import type { GoogleSheetsOptions } from "./types";
+
+async function downloadGoogleSheetsData(spreadsheetId: string, accessToken: string): Promise<string> {
+  try {
+    const client = getClient(accessToken);
+    const response = await client.callDriveApi<string>(
+      `https://www.googleapis.com/drive/v3/files/${spreadsheetId}/export?mimeType=text/csv`,
+      "GET",
+    );
+
+    if (!response.success) {
+      throw new Error(`Failed to download spreadsheet: ${response.status}`);
+    }
+
+    return response.data;
+  } catch (error) {
+    console.error("Error downloading Google Sheets data:", error);
+    throw error;
+  }
+}
+
+async function uploadGoogleSheetsData(
+  spreadsheetId: string,
+  csvLines: string[],
+  accessToken: string,
+): Promise<boolean> {
+  try {
+    const client = getClient(accessToken);
+    // Use resumable upload to ensure the content is properly converted
+    const initResponse = await client.callDriveApi<string>(
+      `https://www.googleapis.com/upload/drive/v3/files/${spreadsheetId}?uploadType=resumable`,
+      "PATCH",
+      {
+        mimeType: "application/vnd.google-apps.spreadsheet",
+      },
+    );
+
+    if (!initResponse.success) {
+      const errorText = initResponse.data;
+      throw new Error(`Failed to initiate upload: ${initResponse.status} - ${errorText}`);
+    }
+
+    const uploadUrl = initResponse.headers.get("Location");
+
+    if (!uploadUrl) {
+      throw new Error("No upload URL returned from Google Drive");
+    }
+
+    // Upload the CSV content
+    const uploadResponse = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "text/csv",
+      },
+      body: csvLines.map((line) => line.replace("\r", "")).join("\n"),
+    });
+    return uploadResponse.ok;
+  } catch (error) {
+    console.error("Error uploading Google Sheets data:", error);
+    throw error;
+  }
+}
+
+export async function saveRecord({
+  formData,
+  options,
+  properties,
+  accessToken,
+}: {
+  formData: FormData;
+  options: GoogleSheetsOptions;
+  properties: TProperties;
+  accessToken: string;
+}): Promise<boolean> {
+  try {
+    if (!accessToken) {
+      throw new Error("Access token is required");
+    }
+
+    if (!options.spreadsheetId) {
+      throw new Error("Spreadsheet ID is required");
+    }
+
+    // Download existing CSV data
+    const existingCsv = await downloadGoogleSheetsData(options.spreadsheetId, accessToken);
+    const csvLines = existingCsv.trim().split("\n");
+
+    // Convert FormData to a record object
+    const record: Record<string, unknown> = {};
+    for (const [key, value] of formData.entries()) {
+      record[key] = value;
+    }
+
+    // build new csv line using the metadata.order of properties
+    const orderedHeaders = buildGoogleSheetHeaders(properties);
+    const newCsvRow = orderedHeaders
+      .map((header) => {
+        const value = record[header]?.toString() || "";
+        // Escape CSV values that contain commas, quotes, or newlines
+        if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+          return `"${value.replace(/"/g, '""')}"`;
+        }
+        return value;
+      })
+      .join(",");
+
+    // Add new rows to CSV
+    csvLines.push(newCsvRow);
+
+    return uploadGoogleSheetsData(options.spreadsheetId, csvLines, accessToken);
+  } catch (error) {
+    console.error("Error pushing data to Google Sheets:", error);
+    return false;
+  }
+}
+
+/**
+ * Create a spreadsheet in Google Sheets
+ * @param title
+ * @param schema
+ * @param accessToken
+ * @returns
+ */
+export async function createTable({
+  name,
+  schema,
+  accessToken,
+}: {
+  name: string;
+  schema: TObject;
+  accessToken: string;
+}): Promise<{ spreadsheetId: string; spreadsheetUrl: string }> {
+  try {
+    const client = getClient(accessToken);
+
+    // First create the file
+    const createResponse = await client.callDriveApi<{ id: string }>(
+      "https://www.googleapis.com/drive/v3/files",
+      "POST",
+      {
+        name: name,
+        mimeType: "application/vnd.google-apps.spreadsheet",
+      },
+    );
+
+    if (!createResponse.success) {
+      throw new Error(`Failed to create spreadsheet: ${createResponse.status}`);
+    }
+
+    const spreadsheetId = createResponse.data.id;
+
+    const spreadsheetUrl = `https://docs.google.com/spreadsheets/d/${spreadsheetId}/edit`;
+
+    const headers = buildGoogleSheetHeaders(schema.properties as TProperties);
+    const headerLine = headers.join(",");
+
+    await uploadGoogleSheetsData(spreadsheetId, [headerLine], accessToken);
+    return {
+      spreadsheetId,
+      spreadsheetUrl,
+    };
+  } catch (error) {
+    console.error("Error creating Google Sheets spreadsheet:", error);
+    throw error;
+  }
+}
+
+function buildGoogleSheetHeaders(properties: TProperties) {
+  // Sort fields by metadata.order (ascending), then fields without order
+  const sortedEntries = Object.entries(properties).sort(([, fieldA], [, fieldB]) => {
+    const orderA = fieldA.metadata?.order;
+    const orderB = fieldB.metadata?.order;
+
+    // If both have order, sort by order value
+    if (orderA !== undefined && orderB !== undefined) {
+      return orderA - orderB;
+    }
+
+    // Fields with order come first
+    if (orderA !== undefined && orderB === undefined) {
+      return -1;
+    }
+
+    if (orderA === undefined && orderB !== undefined) {
+      return 1;
+    }
+
+    // Both without order, maintain original order
+    return 0;
+  });
+
+  const fields = sortedEntries.map(([fieldName, field]) => {
+    return fieldName;
+  });
+  return fields;
+}
+
+export async function updateTable({
+  spreadsheetId,
+  newName,
+  newProperties,
+  accessToken,
+}: {
+  spreadsheetId: string;
+  newName?: string;
+  newProperties?: TProperties;
+  accessToken: string;
+}): Promise<void> {
+  try {
+    // rename spreadsheet
+    if (newName) {
+      const client = getClient(accessToken);
+      await client.callDriveApi<string>(
+        `https://www.googleapis.com/drive/v3/files/${spreadsheetId}`,
+        "PATCH",
+        {
+          name: newName,
+        },
+      );
+    }
+
+    if (newProperties) {
+      const newHeaders = buildGoogleSheetHeaders(newProperties);
+      // const headerLine = newHeaders.join(",");
+
+      // first, download the existing data
+      const existingData = await downloadGoogleSheetsData(spreadsheetId, accessToken);
+
+      // add new header for first line, and empty value for other
+      const currentLines = existingData.split("\n");
+      const csvLines = currentLines.map((line, index) => {
+        if (index === 0) {
+          const currentHeaders = line.split(",");
+          const allHeaders = [...currentHeaders, ...newHeaders];
+          return allHeaders.join(",");
+        } else {
+          const currentValues = line.split(",");
+          const newValues = newHeaders.map(() => "");
+          const updatedValues = [...currentValues, ...newValues];
+          return updatedValues.join(",");
+        }
+      });
+
+      // upload updated data
+      await uploadGoogleSheetsData(spreadsheetId, csvLines, accessToken);
+    }
+  } catch (error) {
+    console.error("Error updating Google Sheets spreadsheet:", error);
+    throw error;
+  }
+}

package/src/shared/datarecords/external/google/sheets/types.ts

@@ -0,0 +1,10 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const googleSheetsOptions = Type.Object({
+  spreadsheetId: Type.String(),
+  spreadsheetUrl: Type.Optional(Type.String()),
+  spreadsheetName: Type.Optional(Type.String()),
+  externalUrl: Type.Optional(Type.String()),
+});
+
+export type GoogleSheetsOptions = Static<typeof googleSheetsOptions>;