digital-tools 2.1.3 → 2.3.0

package/src/providers/spreadsheet/google-sheets.ts

@@ -28,6 +28,129 @@ import { defineProvider } from '../registry.js'
 const SHEETS_API_URL = 'https://sheets.googleapis.com/v4/spreadsheets'
 const DRIVE_API_URL = 'https://www.googleapis.com/drive/v3/files'
 
+// =============================================================================
+// Google Sheets API Response Types
+// =============================================================================
+
+/** Google API error response */
+interface GoogleErrorResponse {
+  error?: {
+    message?: string
+    code?: number
+  }
+}
+
+/** Google Drive file from list response */
+interface GoogleDriveFile {
+  id: string
+  name: string
+  createdTime?: string
+  modifiedTime?: string
+}
+
+/** Google Drive list response */
+interface GoogleDriveListResponse {
+  files?: GoogleDriveFile[]
+  nextPageToken?: string
+}
+
+/** Google Sheets grid properties */
+interface GoogleGridProperties {
+  rowCount?: number
+  columnCount?: number
+  frozenRowCount?: number
+  frozenColumnCount?: number
+}
+
+/** Google Sheets sheet properties */
+interface GoogleSheetProperties {
+  sheetId: number
+  title: string
+  index: number
+  gridProperties?: GoogleGridProperties
+}
+
+/** Google Sheets cell effective value */
+interface GoogleCellEffectiveValue {
+  numberValue?: number
+  stringValue?: string
+  boolValue?: boolean
+  formulaValue?: string
+  errorValue?: { message: string }
+}
+
+/** Google Sheets cell data */
+interface GoogleCellData {
+  effectiveValue?: GoogleCellEffectiveValue
+}
+
+/** Google Sheets row data */
+interface GoogleRowData {
+  values?: GoogleCellData[]
+}
+
+/** Google Sheets grid data */
+interface GoogleGridData {
+  rowData?: GoogleRowData[]
+}
+
+/** Google Sheets sheet from API */
+interface GoogleSheet {
+  properties: GoogleSheetProperties
+  data?: GoogleGridData[]
+}
+
+/** Google Sheets spreadsheet from API */
+interface GoogleSpreadsheet {
+  spreadsheetId: string
+  properties: { title: string }
+  sheets?: GoogleSheet[]
+  spreadsheetUrl?: string
+}
+
+/** Google Sheets value range from API */
+interface GoogleValueRange {
+  range: string
+  values?: CellValue[][]
+}
+
+/** Google Sheets batch update reply */
+interface GoogleBatchUpdateReply {
+  addSheet?: {
+    properties: GoogleSheetProperties
+  }
+}
+
+/** Google Sheets batch update response */
+interface GoogleBatchUpdateResponse {
+  replies: GoogleBatchUpdateReply[]
+}
+
+/** Google Sheets value update response */
+interface GoogleValueUpdateResponse {
+  spreadsheetId: string
+  updatedRange?: string
+  updatedRows?: number
+  updatedColumns?: number
+  updatedCells?: number
+  updates?: {
+    updatedRange?: string
+    updatedRows?: number
+  }
+}
+
+/** Google Sheets batch get response */
+interface GoogleBatchGetResponse {
+  valueRanges?: GoogleValueRange[]
+}
+
+/** Google Sheets batch value update response */
+interface GoogleBatchValueUpdateResponse {
+  totalUpdatedRows?: number
+  totalUpdatedColumns?: number
+  totalUpdatedCells?: number
+}
+
 /**
  * Google Sheets provider info
  */
@@ -48,12 +171,12 @@ export const googleSheetsInfo: ProviderInfo = {
 export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetProvider {
   let accessToken: string
 
-  async function sheetsApi(
+  async function sheetsApi<T>(
     path: string,
     method: string = 'GET',
     body?: unknown,
     baseUrl: string = SHEETS_API_URL
-  ): Promise<any> {
+  ): Promise<T> {
     const url = path.startsWith('http') ? path : `${baseUrl}${path}`
 
     const response = await fetch(url, {
@@ -62,15 +185,15 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
         'Content-Type': 'application/json',
         Authorization: `Bearer ${accessToken}`,
       },
-      body: body ? JSON.stringify(body) : undefined,
+      ...(body !== undefined && { body: JSON.stringify(body) }),
     })
 
     if (!response.ok) {
-      const error = await response.json().catch(() => ({}))
-      throw new Error((error as any)?.error?.message || `HTTP ${response.status}`)
+      const error = (await response.json().catch(() => ({}))) as GoogleErrorResponse
+      throw new Error(error.error?.message || `HTTP ${response.status}`)
     }
 
-    return response.json()
+    return response.json() as Promise<T>
   }
 
   return {
@@ -125,14 +248,14 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
         })),
       }
 
-      const data = await sheetsApi('', 'POST', body)
+      const data = await sheetsApi<GoogleSpreadsheet>('', 'POST', body)
 
       return mapSpreadsheet(data)
     },
 
     async get(spreadsheetId: string): Promise<SpreadsheetData | null> {
       try {
-        const data = await sheetsApi(`/${spreadsheetId}?includeGridData=false`)
+        const data = await sheetsApi<GoogleSpreadsheet>(`/${spreadsheetId}?includeGridData=false`)
         return mapSpreadsheet(data)
       } catch {
         return null
@@ -141,7 +264,9 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
 
     async list(options?: SpreadsheetListOptions): Promise<PaginatedResult<SpreadsheetData>> {
       const params = new URLSearchParams({
-        q: `mimeType='application/vnd.google-apps.spreadsheet'${options?.query ? ` and name contains '${options.query}'` : ''}`,
+        q: `mimeType='application/vnd.google-apps.spreadsheet'${
+          options?.query ? ` and name contains '${options.query}'` : ''
+        }`,
         pageSize: (options?.limit || 100).toString(),
         fields: 'files(id,name,createdTime,modifiedTime),nextPageToken',
       })
@@ -150,19 +275,25 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
         params.append('pageToken', options.cursor)
       }
 
-      const data = await sheetsApi(`?${params.toString()}`, 'GET', undefined, DRIVE_API_URL)
+      const data = await sheetsApi<GoogleDriveListResponse>(
+        `?${params.toString()}`,
+        'GET',
+        undefined,
+        DRIVE_API_URL
+      )
 
       return {
-        items: data.files?.map((f: any) => ({
-          id: f.id,
-          name: f.name,
-          sheets: [], // Would need separate API call to get sheets
-          createdAt: f.createdTime ? new Date(f.createdTime) : undefined,
-          modifiedAt: f.modifiedTime ? new Date(f.modifiedTime) : undefined,
-          url: `https://docs.google.com/spreadsheets/d/${f.id}`,
-        })) || [],
+        items:
+          data.files?.map((f) => ({
+            id: f.id,
+            name: f.name,
+            sheets: [], // Would need separate API call to get sheets
+            ...(f.createdTime && { createdAt: new Date(f.createdTime) }),
+            ...(f.modifiedTime && { modifiedAt: new Date(f.modifiedTime) }),
+            url: `https://docs.google.com/spreadsheets/d/${f.id}`,
+          })) || [],
         hasMore: !!data.nextPageToken,
-        nextCursor: data.nextPageToken,
+        ...(data.nextPageToken !== undefined && { nextCursor: data.nextPageToken }),
       }
     },
 
@@ -177,11 +308,14 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
 
     async getSheet(spreadsheetId: string, sheetId: string | number): Promise<SheetData | null> {
       try {
-        const spreadsheet = await sheetsApi(`/${spreadsheetId}?includeGridData=true`)
+        const spreadsheet = await sheetsApi<GoogleSpreadsheet>(
+          `/${spreadsheetId}?includeGridData=true`
+        )
 
-        const sheet = typeof sheetId === 'number'
-          ? spreadsheet.sheets.find((s: any) => s.properties.sheetId === sheetId)
-          : spreadsheet.sheets.find((s: any) => s.properties.title === sheetId)
+        const sheet =
+          typeof sheetId === 'number'
+            ? spreadsheet.sheets?.find((s) => s.properties.sheetId === sheetId)
+            : spreadsheet.sheets?.find((s) => s.properties.title === sheetId)
 
         if (!sheet) return null
 
@@ -208,15 +342,23 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
           rowCount: sheet.properties.gridProperties?.rowCount || 0,
           columnCount: sheet.properties.gridProperties?.columnCount || 0,
           data,
-          frozenRows: sheet.properties.gridProperties?.frozenRowCount,
-          frozenColumns: sheet.properties.gridProperties?.frozenColumnCount,
+          ...(sheet.properties.gridProperties?.frozenRowCount !== undefined && {
+            frozenRows: sheet.properties.gridProperties.frozenRowCount,
+          }),
+          ...(sheet.properties.gridProperties?.frozenColumnCount !== undefined && {
+            frozenColumns: sheet.properties.gridProperties.frozenColumnCount,
+          }),
         }
       } catch {
         return null
       }
     },
 
-    async addSheet(spreadsheetId: string, name: string, options?: AddSheetOptions): Promise<SheetData> {
+    async addSheet(
+      spreadsheetId: string,
+      name: string,
+      options?: AddSheetOptions
+    ): Promise<SheetData> {
       const body = {
         requests: [
           {
@@ -234,9 +376,13 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
         ],
       }
 
-      const data = await sheetsApi(`/${spreadsheetId}:batchUpdate`, 'POST', body)
+      const data = await sheetsApi<GoogleBatchUpdateResponse>(
+        `/${spreadsheetId}:batchUpdate`,
+        'POST',
+        body
+      )
 
-      const reply = data.replies[0].addSheet
+      const reply = data.replies[0]!.addSheet!
       return {
         id: reply.properties.sheetId.toString(),
         name: reply.properties.title,
@@ -253,8 +399,8 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
 
         if (isNaN(actualSheetId)) {
           // Look up by name
-          const spreadsheet = await sheetsApi(`/${spreadsheetId}`)
-          const sheet = spreadsheet.sheets.find((s: any) => s.properties.title === sheetId)
+          const spreadsheet = await sheetsApi<GoogleSpreadsheet>(`/${spreadsheetId}`)
+          const sheet = spreadsheet.sheets?.find((s) => s.properties.title === sheetId)
           if (!sheet) return false
           actualSheetId = sheet.properties.sheetId
         }
@@ -276,13 +422,17 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
       }
     },
 
-    async renameSheet(spreadsheetId: string, sheetId: string | number, name: string): Promise<boolean> {
+    async renameSheet(
+      spreadsheetId: string,
+      sheetId: string | number,
+      name: string
+    ): Promise<boolean> {
       try {
         let actualSheetId = typeof sheetId === 'number' ? sheetId : parseInt(sheetId, 10)
 
         if (isNaN(actualSheetId)) {
-          const spreadsheet = await sheetsApi(`/${spreadsheetId}`)
-          const sheet = spreadsheet.sheets.find((s: any) => s.properties.title === sheetId)
+          const spreadsheet = await sheetsApi<GoogleSpreadsheet>(`/${spreadsheetId}`)
+          const sheet = spreadsheet.sheets?.find((s) => s.properties.title === sheetId)
           if (!sheet) return false
           actualSheetId = sheet.properties.sheetId
         }
@@ -301,7 +451,7 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
           ],
         }
 
-        await sheetsApi(`/${spreadsheetId}:batchUpdate`, 'POST', body)
+        await sheetsApi<GoogleBatchUpdateResponse>(`/${spreadsheetId}:batchUpdate`, 'POST', body)
         return true
       } catch {
         return false
@@ -309,39 +459,49 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
     },
 
     async readRange(spreadsheetId: string, range: string): Promise<CellValue[][]> {
-      const data = await sheetsApi(
+      const data = await sheetsApi<GoogleValueRange>(
         `/${spreadsheetId}/values/${encodeURIComponent(range)}?valueRenderOption=UNFORMATTED_VALUE`
       )
 
       return data.values || []
     },
 
-    async writeRange(spreadsheetId: string, range: string, values: CellValue[][]): Promise<UpdateResult> {
+    async writeRange(
+      spreadsheetId: string,
+      range: string,
+      values: CellValue[][]
+    ): Promise<UpdateResult> {
       const body = {
         values,
       }
 
-      const data = await sheetsApi(
+      const data = await sheetsApi<GoogleValueUpdateResponse>(
         `/${spreadsheetId}/values/${encodeURIComponent(range)}?valueInputOption=USER_ENTERED`,
         'PUT',
         body
       )
 
       return {
-        updatedRange: data.updatedRange,
+        updatedRange: data.updatedRange || range,
         updatedRows: data.updatedRows || 0,
         updatedColumns: data.updatedColumns || 0,
         updatedCells: data.updatedCells || 0,
       }
     },
 
-    async appendRows(spreadsheetId: string, range: string, values: CellValue[][]): Promise<AppendResult> {
+    async appendRows(
+      spreadsheetId: string,
+      range: string,
+      values: CellValue[][]
+    ): Promise<AppendResult> {
       const body = {
         values,
       }
 
-      const data = await sheetsApi(
-        `/${spreadsheetId}/values/${encodeURIComponent(range)}:append?valueInputOption=USER_ENTERED&insertDataOption=INSERT_ROWS`,
+      const data = await sheetsApi<GoogleValueUpdateResponse>(
+        `/${spreadsheetId}/values/${encodeURIComponent(
+          range
+        )}:append?valueInputOption=USER_ENTERED&insertDataOption=INSERT_ROWS`,
         'POST',
         body
       )
@@ -364,12 +524,12 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
 
     async batchRead(spreadsheetId: string, ranges: string[]): Promise<Map<string, CellValue[][]>> {
       const params = ranges.map((r) => `ranges=${encodeURIComponent(r)}`).join('&')
-      const data = await sheetsApi(
+      const data = await sheetsApi<GoogleBatchGetResponse>(
         `/${spreadsheetId}/values:batchGet?${params}&valueRenderOption=UNFORMATTED_VALUE`
       )
 
       const result = new Map<string, CellValue[][]>()
-      data.valueRanges?.forEach((vr: any) => {
+      data.valueRanges?.forEach((vr) => {
         result.set(vr.range, vr.values || [])
       })
 
@@ -388,7 +548,11 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
         })),
       }
 
-      const response = await sheetsApi(`/${spreadsheetId}/values:batchUpdate`, 'POST', body)
+      const response = await sheetsApi<GoogleBatchValueUpdateResponse>(
+        `/${spreadsheetId}/values:batchUpdate`,
+        'POST',
+        body
+      )
 
       return {
         updatedRange: 'batch',
@@ -406,7 +570,9 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
       }
 
       const response = await fetch(
-        `${DRIVE_API_URL}/${spreadsheetId}/export?mimeType=${encodeURIComponent(mimeTypes[format]!)}`,
+        `${DRIVE_API_URL}/${spreadsheetId}/export?mimeType=${encodeURIComponent(
+          mimeTypes[format]!
+        )}`,
         {
           headers: {
             Authorization: `Bearer ${accessToken}`,
@@ -424,20 +590,20 @@ export function createGoogleSheetsProvider(config: ProviderConfig): SpreadsheetP
   }
 }
 
-function mapSpreadsheet(data: any): SpreadsheetData {
+function mapSpreadsheet(data: GoogleSpreadsheet): SpreadsheetData {
   return {
     id: data.spreadsheetId,
     name: data.properties.title,
-    sheets: data.sheets?.map((s: any) => ({
-      id: s.properties.sheetId.toString(),
-      name: s.properties.title,
-      index: s.properties.index,
-      rowCount: s.properties.gridProperties?.rowCount,
-      columnCount: s.properties.gridProperties?.columnCount,
-    })) || [],
-    createdAt: undefined, // Not available from Sheets API
-    modifiedAt: undefined,
-    url: data.spreadsheetUrl,
+    sheets:
+      data.sheets?.map((s) => ({
+        id: s.properties.sheetId.toString(),
+        name: s.properties.title,
+        index: s.properties.index,
+        rowCount: s.properties.gridProperties?.rowCount ?? 0,
+        columnCount: s.properties.gridProperties?.columnCount ?? 0,
+      })) || [],
+    // createdAt and modifiedAt not available from Sheets API
+    ...(data.spreadsheetUrl !== undefined && { url: data.spreadsheetUrl }),
   }
 }
 

package/src/providers/spreadsheet/xlsx.ts

@@ -69,7 +69,13 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
     return `xlsx_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`
   }
 
-  function parseRange(range: string): { sheet?: string; startRow: number; startCol: number; endRow: number; endCol: number } {
+  function parseRange(range: string): {
+    sheet?: string
+    startRow: number
+    startCol: number
+    endRow: number
+    endCol: number
+  } {
     // Parse A1 notation like "Sheet1!A1:C10" or just "A1:C10"
     let sheetName: string | undefined
     let cellRange = range
@@ -85,7 +91,7 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
     const endCell = end ? parseCell(end) : startCell
 
     return {
-      sheet: sheetName,
+      ...(sheetName !== undefined && { sheet: sheetName }),
       startRow: startCell.row,
       startCol: startCell.col,
       endRow: endCell.row,
@@ -125,7 +131,7 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
     info: xlsxInfo,
 
     async initialize(cfg: ProviderConfig): Promise<void> {
-      basePath = (cfg.basePath as string) || './spreadsheets'
+      basePath = (cfg['basePath'] as string) || './spreadsheets'
     },
 
     async healthCheck(): Promise<ProviderHealth> {
@@ -252,12 +258,16 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
         rowCount: sheet.data.length,
         columnCount: sheet.data[0]?.length || 0,
         data: sheet.data,
-        frozenRows: sheet.frozenRows,
-        frozenColumns: sheet.frozenColumns,
+        ...(sheet.frozenRows !== undefined && { frozenRows: sheet.frozenRows }),
+        ...(sheet.frozenColumns !== undefined && { frozenColumns: sheet.frozenColumns }),
       }
     },
 
-    async addSheet(spreadsheetId: string, name: string, options?: AddSheetOptions): Promise<SheetData> {
+    async addSheet(
+      spreadsheetId: string,
+      name: string,
+      options?: AddSheetOptions
+    ): Promise<SheetData> {
       const workbook = spreadsheets.get(spreadsheetId)
       if (!workbook) {
         throw new Error(`Spreadsheet ${spreadsheetId} not found`)
@@ -309,7 +319,11 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
       return deleted
     },
 
-    async renameSheet(spreadsheetId: string, sheetId: string | number, name: string): Promise<boolean> {
+    async renameSheet(
+      spreadsheetId: string,
+      sheetId: string | number,
+      name: string
+    ): Promise<boolean> {
       const workbook = spreadsheets.get(spreadsheetId)
       if (!workbook) return false
 
@@ -364,7 +378,11 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
       return result
     },
 
-    async writeRange(spreadsheetId: string, range: string, values: CellValue[][]): Promise<UpdateResult> {
+    async writeRange(
+      spreadsheetId: string,
+      range: string,
+      values: CellValue[][]
+    ): Promise<UpdateResult> {
       const workbook = spreadsheets.get(spreadsheetId)
       if (!workbook) {
         throw new Error(`Spreadsheet ${spreadsheetId} not found`)
@@ -402,14 +420,20 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
       const endCol = startCol + (values[0]?.length || 0) - 1
 
       return {
-        updatedRange: `${sheetName || sheet.name}!${colToLetter(startCol)}${startRow}:${colToLetter(endCol)}${endRow}`,
+        updatedRange: `${sheetName || sheet.name}!${colToLetter(startCol)}${startRow}:${colToLetter(
+          endCol
+        )}${endRow}`,
         updatedRows: values.length,
         updatedColumns: values[0]?.length || 0,
         updatedCells,
       }
     },
 
-    async appendRows(spreadsheetId: string, range: string, values: CellValue[][]): Promise<AppendResult> {
+    async appendRows(
+      spreadsheetId: string,
+      range: string,
+      values: CellValue[][]
+    ): Promise<AppendResult> {
       const workbook = spreadsheets.get(spreadsheetId)
       if (!workbook) {
         throw new Error(`Spreadsheet ${spreadsheetId} not found`)
@@ -446,7 +470,9 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
 
       return {
         spreadsheetId,
-        updatedRange: `${sheetName || sheet.name}!${colToLetter(startCol)}${startRow}:${colToLetter(endCol)}${endRow}`,
+        updatedRange: `${sheetName || sheet.name}!${colToLetter(startCol)}${startRow}:${colToLetter(
+          endCol
+        )}${endRow}`,
         updatedRows: values.length,
       }
     },
@@ -486,7 +512,10 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
       return result
     },
 
-    async batchWrite(spreadsheetId: string, data: Array<{ range: string; values: CellValue[][] }>): Promise<UpdateResult> {
+    async batchWrite(
+      spreadsheetId: string,
+      data: Array<{ range: string; values: CellValue[][] }>
+    ): Promise<UpdateResult> {
       let totalCells = 0
       let totalRows = 0
       let totalCols = 0
@@ -525,7 +554,11 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
       return Buffer.from(content, 'utf-8')
     },
 
-    async import(file: Buffer, format: 'xlsx' | 'csv', options?: ImportOptions): Promise<SpreadsheetData> {
+    async import(
+      file: Buffer,
+      format: 'xlsx' | 'csv',
+      options?: ImportOptions
+    ): Promise<SpreadsheetData> {
       // In a real implementation, this would use SheetJS to parse the file
       // For now, create an empty spreadsheet
       const name = options?.name || `Imported_${Date.now()}`
@@ -537,6 +570,4 @@ export function createXlsxProvider(config: ProviderConfig): SpreadsheetProvider
 /**
  * XLSX provider definition
  */
-export const xlsxProvider = defineProvider(xlsxInfo, async (config) =>
-  createXlsxProvider(config)
-)
+export const xlsxProvider = defineProvider(xlsxInfo, async (config) => createXlsxProvider(config))