Google Sheets

google-sheets/actions/batchUpdateValues.ts

@@ -0,0 +1,152 @@
+import { AppContext } from "../mod.ts";
+import type {
+  Result,
+  SimpleBatchUpdateProps,
+  SimpleBatchUpdateResponse,
+  SimpleError,
+  SimpleValueRange,
+} from "../utils/types.ts";
+import {
+  mapApiBatchUpdateResponseToSimple,
+  mapSimpleBatchUpdatePropsToApi,
+  parseApiErrorText,
+  validateSimpleBatchUpdateProps,
+} from "../utils/mappers.ts";
+import { buildFullRange } from "../utils/rangeUtils.ts";
+
+/**
+ * Simplified props for batch updating values
+ */
+export interface Props {
+  /**
+   * @title First Cell Location
+   * @description The starting cell for the update range, specified in A1 notation (e.g., 'A1', 'B2')
+   */
+  first_cell_location?: string;
+
+  /**
+   * @title Include Values in Response
+   * @description Whether to return the updated values in the API response
+   */
+  includeValuesInResponse?: boolean;
+
+  /**
+   * @title Sheet Name
+   * @description The name of the specific sheet within the spreadsheet to update
+   */
+  sheet_name: string;
+
+  /**
+   * @title Spreadsheet ID
+   * @description The unique identifier of the Google Sheets spreadsheet to be updated
+   */
+  spreadsheet_id: string;
+
+  /**
+   * @title Value Input Option
+   * @description Use 'RAW' to store values as-is or 'USER_ENTERED' to interpret formulas
+   */
+  valueInputOption?: "RAW" | "USER_ENTERED";
+
+  /**
+   * @title Values
+   * @description A 2D list representing the values to update. Each inner list corresponds to a row in the spreadsheet
+   */
+  values: string[][];
+}
+
+/**
+ * Maps simplified props to the expected API format
+ */
+function mapPropsToApiFormat(props: Props): SimpleBatchUpdateProps {
+  const firstCell = props.first_cell_location || "A1";
+  const range = buildFullRange(props.sheet_name, firstCell, props.values);
+
+  const simpleData: SimpleValueRange[] = [{
+    range: range,
+    values: props.values,
+    majorDimension: "ROWS",
+  }];
+
+  return {
+    spreadsheetId: props.spreadsheet_id,
+    data: simpleData,
+    valueInputOption: props.valueInputOption || "USER_ENTERED",
+    includeValuesInResponse: props.includeValuesInResponse || false,
+    responseValueRenderOption: "FORMATTED_VALUE",
+    responseDateTimeRenderOption: "SERIAL_NUMBER",
+  };
+}
+
+/**
+ * @name BATCH_UPDATE_SPREADSHEET_VALUES
+ * @title Batch Update Spreadsheet Values
+ * @description Updates values in a Google Sheets spreadsheet in a simple and intuitive way. Just specify the sheet name, starting cell and data, and the system will automatically calculate the required range.
+ */
+const action = async (
+  props: Props,
+  _req: Request,
+  ctx: AppContext,
+): Promise<Result<SimpleBatchUpdateResponse>> => {
+  // Basic validations
+  if (!props.spreadsheet_id || !props.sheet_name || !props.values) {
+    return {
+      message:
+        "Missing required parameters: spreadsheet_id, sheet_name and values are required",
+    } as SimpleError;
+  }
+
+  if (!Array.isArray(props.values) || props.values.length === 0) {
+    return {
+      message: "The 'values' parameter must be a non-empty array of arrays",
+    } as SimpleError;
+  }
+
+  // Check if all elements of values are arrays
+  if (!props.values.every((row) => Array.isArray(row))) {
+    return {
+      message: "All elements in 'values' must be arrays (representing rows)",
+    } as SimpleError;
+  }
+
+  try {
+    // Map simple props to API format
+    const simpleProps = mapPropsToApiFormat(props);
+
+    // Validate mapped props
+    const validationErrors = validateSimpleBatchUpdateProps(simpleProps);
+    if (validationErrors.length > 0) {
+      return {
+        message: `Validation error: ${validationErrors.join(", ")}`,
+      } as SimpleError;
+    }
+
+    // Map to Google API format
+    const { body, params } = mapSimpleBatchUpdatePropsToApi(simpleProps);
+
+    // Make API call
+    const response = await ctx.client
+      ["POST /v4/spreadsheets/:spreadsheetId/values:batchUpdate"](
+        params,
+        { body },
+      );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return parseApiErrorText(errorText);
+    }
+
+    // Map API response to simple format
+    const apiResponse = await response.json();
+    return mapApiBatchUpdateResponseToSimple(apiResponse);
+  } catch (error) {
+    return {
+      message: `Communication error: ${
+        error instanceof Error ? error.message : "Unknown error"
+      }`,
+      details: { originalError: error },
+    } as SimpleError;
+  }
+};
+
+export default action;

google-sheets/actions/createSpreadsheet.ts

@@ -0,0 +1,106 @@
+import { AppContext } from "../mod.ts";
+import { Spreadsheet } from "../utils/types.ts";
+
+export interface Props {
+  /**
+   * @title Spreadsheet Title
+   * @description The title for the new spreadsheet
+   */
+  title: string;
+
+  /**
+   * @title Locale
+   * @description The locale code for the spreadsheet
+   */
+  locale?: string;
+
+  /**
+   * @title Time Zone
+   * @description The time zone of the spreadsheet
+   */
+  timeZone?: string;
+
+  /**
+   * @title Auto Recalculate
+   * @description When formulas should be recalculated
+   */
+  autoRecalc?: "ON_CHANGE" | "MINUTE" | "HOUR";
+
+  /**
+   * @title Initial Sheets
+   * @description Configuration of the initial sheets in the spreadsheet
+   */
+  sheets?: Array<{
+    /**
+     * @title Sheet Title
+     * @description Title of the sheet to be created
+     */
+    title: string;
+
+    /**
+     * @title Row Count
+     * @description Number of rows in the sheet
+     */
+    rowCount?: number;
+
+    /**
+     * @title Column Count
+     * @description Number of columns in the sheet
+     */
+    columnCount?: number;
+  }>;
+}
+
+/**
+ * @name CREATE_SPREADSHEET
+ * @title Create Spreadsheet
+ * @description Creates a new spreadsheet in Google Sheets
+ */
+const action = async (
+  props: Props,
+  _req: Request,
+  ctx: AppContext,
+): Promise<Spreadsheet | { error: string }> => {
+  const {
+    title,
+    locale = "pt_BR",
+    timeZone = "America/Sao_Paulo",
+    autoRecalc = "ON_CHANGE",
+    sheets = [{ title: "Sheet1", rowCount: 1000, columnCount: 26 }],
+  } = props;
+
+  const { client } = ctx;
+
+  const requestBody = {
+    properties: {
+      title,
+      locale,
+      timeZone,
+      autoRecalc,
+    },
+    sheets: sheets.map((sheet) => ({
+      properties: {
+        title: sheet.title,
+        gridProperties: {
+          rowCount: sheet.rowCount,
+          columnCount: sheet.columnCount,
+        },
+      },
+    })),
+  };
+
+  const response = await client["POST /v4/spreadsheets"]({}, {
+    body: requestBody,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      error: errorText,
+    };
+  }
+
+  return await response.json();
+};
+
+export default action;

google-sheets/actions/oauth/callback.ts

@@ -0,0 +1,68 @@
+import { AppContext } from "../../mod.ts";
+
+interface OAuthCallbackResponse {
+  access_token: string;
+  expires_in: number;
+  refresh_token: string;
+  scope: string;
+  token_type: string;
+}
+
+export interface Props {
+  code: string;
+  installId: string;
+  clientId: string;
+  clientSecret: string;
+  redirectUri: string;
+}
+
+/**
+ * @name OAUTH_CALLBACK
+ * @title OAuth Google Callback
+ * @description Exchanges the authorization code for access tokens
+ */
+export default async function callback(
+  { code, installId, clientId, clientSecret, redirectUri }: Props,
+  req: Request,
+  ctx: AppContext,
+): Promise<{ installId: string }> {
+  const { client } = ctx;
+
+  const finalRedirectUri = redirectUri ||
+    new URL("/oauth/callback", req.url).href;
+
+  const response = await client["POST /token"]({
+    code,
+    client_id: clientId,
+    client_secret: clientSecret,
+    redirect_uri: finalRedirectUri,
+    grant_type: "authorization_code",
+  });
+
+  const tokenData = await response.json() as OAuthCallbackResponse;
+  const currentTime = Math.floor(Date.now() / 1000);
+
+  client.oauth.tokens.access_token = tokenData.access_token;
+  client.oauth.tokens.refresh_token = tokenData.refresh_token;
+  client.oauth.tokens.expires_in = tokenData.expires_in;
+  client.oauth.tokens.scope = tokenData.scope;
+  client.oauth.tokens.token_type = tokenData.token_type;
+  client.oauth.tokens.tokenObtainedAt = currentTime;
+
+  const currentCtx = await ctx.getConfiguration();
+  await ctx.configure({
+    ...currentCtx,
+    tokens: {
+      access_token: tokenData.access_token,
+      refresh_token: tokenData.refresh_token,
+      expires_in: tokenData.expires_in,
+      scope: tokenData.scope,
+      token_type: tokenData.token_type,
+      tokenObtainedAt: currentTime,
+    },
+    clientSecret: clientSecret,
+    clientId: clientId,
+  });
+
+  return { installId };
+}