bump deps

.bumpy/update-deps.md

@@ -0,0 +1,5 @@
+---
+google-spreadsheet: patch
+---
+
+bump deps

.env.schema

@@ -24,4 +24,4 @@ CI=
 
 # Delay in ms to use when running tests
 # @type=number
-TEST_DELAY=200
+TEST_DELAY=if($CI, 300, 200)

package.json

@@ -51,14 +51,14 @@
     "test:ci": "vitest run"
   },
   "dependencies": {
-    "es-toolkit": "^1.44.0",
-    "ky": "^1.14.3"
+    "es-toolkit": "^1.46.1",
+    "ky": "^2.0.2"
   },
   "devDependencies": {
     "@types/node": "^25.2.3",
     "@typescript-eslint/eslint-plugin": "^5.59.7",
     "@typescript-eslint/parser": "^5.59.7",
-    "@varlock/bumpy": "^1.5.1",
+    "@varlock/bumpy": "^1.6.0",
     "docsify-cli": "^4.4.4",
     "eslint": "^8.41.0",
     "eslint-config-airbnb-base": "^15.0.0",

src/lib/GoogleSpreadsheet.ts

@@ -142,19 +142,23 @@
 
     // create a ky instance with sheet root URL and hooks to handle auth
     this.sheetsApi = ky.create({
-      prefixUrl: `${SHEETS_API_BASE_URL}/${spreadsheetId}`,
+      prefix: `${SHEETS_API_BASE_URL}/${spreadsheetId}`,
       timeout: 180_000,
       hooks: {
-        beforeRequest: [(r) => this._setAuthRequestHook(r)],
-        beforeError: [(e) => this._errorHook(e)],
+        beforeRequest: [
+          ({ request }) => this._setAuthRequestHook(request),
+        ],
+        beforeError: [
+          ({ error }) => this._errorHook(error),
+        ],
       },
       retry: retryConfig,
     });
     this.driveApi = ky.create({
-      prefixUrl: `${DRIVE_API_BASE_URL}/${spreadsheetId}`,
+      prefix: `${DRIVE_API_BASE_URL}/${spreadsheetId}`,
       hooks: {
-        beforeRequest: [(r) => this._setAuthRequestHook(r)],
-        beforeError: [(e) => this._errorHook(e)],
+        beforeRequest: [({ request }) => this._setAuthRequestHook(request)],
+        beforeError: [({ error }) => this._errorHook(error)],
       },
       retry: retryConfig,
     });
@@ -185,26 +189,21 @@
   }
 
   /** @internal */
-  async _errorHook(error: HTTPError) {
-    const { response } = error;
-    const errorDataText = await response?.text();
-    let errorData;
-    try {
-      errorData = JSON.parse(errorDataText);
-    } catch (e) {
-      // console.log('parsing json failed', errorDataText);
-    }
+  async _errorHook(error: Error) {
+    if (!(error instanceof HTTPError)) return error;
 
-    if (errorData) {
-      // usually the error has a code and message, but occasionally not
-      if (!errorData.error) return error;
+    // ky pre-parses the response body into error.data (the response body is already consumed)
+    const errorData = typeof error.data === 'string' ? (() => {
+      try { return JSON.parse(error.data as string); } catch { return undefined; }
+    })() : error.data;
 
+    if (errorData?.error) {
       const { code, message } = errorData.error;
       error.message = `Google API error - [${code}] ${message}`;
       return error;
     }
 
-    if (_.get(error, 'response.status') === 403) {
+    if (error.response?.status === 403) {
       if ('apiKey' in this.auth) {
         throw new Error('Sheet is private. Use authentication or make public. (see https://github.com/theoephraim/node-google-spreadsheet#a-note-on-authentication for details)');
       }
@@ -493,8 +492,8 @@
     if (!this._spreadsheetUrl) throw new Error('Cannot export sheet that is not fully loaded');
 
     const exportUrl = this._spreadsheetUrl.replace('edit', 'export');
     const response = await this.sheetsApi.get(exportUrl, {
-      prefixUrl: '', // unset baseUrl since we're not hitting the normal sheets API
+      prefix: '', // unset baseUrl since we're not hitting the normal sheets API
       searchParams: {
         id: this.spreadsheetId,
         format: fileType,

src/test/exports.test.ts

@@ -0,0 +1,107 @@
+import {
+  describe, expect, it, beforeAll, afterAll, afterEach,
+} from 'vitest';
+import { setTimeout as delay } from 'timers/promises';
+import { ENV } from 'varlock/env';
+
+import { GoogleSpreadsheet, GoogleSpreadsheetWorksheet } from '..';
+
+import { DOC_IDS, testServiceAccountAuth } from './auth/docs-and-auth';
+
+const doc = new GoogleSpreadsheet(DOC_IDS.private, testServiceAccountAuth);
+let sheet: GoogleSpreadsheetWorksheet;
+
+describe('Export/download methods', () => {
+  beforeAll(async () => {
+    await doc.loadInfo();
+    sheet = await doc.addSheet({
+      title: `Export test ${+new Date()}`,
+      headerValues: ['name', 'value'],
+    });
+    await sheet.addRows([
+      { name: 'Alice', value: '100' },
+      { name: 'Bob', value: '200' },
+      { name: 'Charlie', value: '300' },
+    ]);
+  });
+
+  afterAll(async () => {
+    await sheet.delete();
+  });
+
+  // hitting rate limits when running tests on ci - so we add a short delay
+  if (ENV.TEST_DELAY) afterEach(async () => delay(ENV.TEST_DELAY));
+
+  describe('document-level exports', () => {
+    it('can download as XLSX', async () => {
+      const buffer = await doc.downloadAsXLSX();
+      expect(buffer).toBeInstanceOf(ArrayBuffer);
+      expect(buffer.byteLength).toBeGreaterThan(0);
+    });
+
+    it('can download as XLSX stream', async () => {
+      const stream = await doc.downloadAsXLSX(true);
+      expect(stream).toBeTruthy();
+      // ReadableStream should have a getReader method
+      expect(typeof (stream as ReadableStream).getReader).toBe('function');
+    });
+
+    it('can download as ODS', async () => {
+      const buffer = await doc.downloadAsODS();
+      expect(buffer).toBeInstanceOf(ArrayBuffer);
+      expect(buffer.byteLength).toBeGreaterThan(0);
+    });
+
+    it('can download as zipped HTML', async () => {
+      const buffer = await doc.downloadAsZippedHTML();
+      expect(buffer).toBeInstanceOf(ArrayBuffer);
+      expect(buffer.byteLength).toBeGreaterThan(0);
+    });
+  });
+
+  describe('worksheet-level exports', () => {
+    it('can download as CSV and verify content', async () => {
+      const buffer = await sheet.downloadAsCSV();
+      expect(buffer).toBeInstanceOf(ArrayBuffer);
+      expect(buffer.byteLength).toBeGreaterThan(0);
+
+      const csvText = new TextDecoder().decode(buffer);
+      const lines = csvText.trim().split('\n');
+
+      // header row
+      expect(lines[0]).toContain('name');
+      expect(lines[0]).toContain('value');
+
+      // data rows
+      expect(lines[1]).toContain('Alice');
+      expect(lines[1]).toContain('100');
+      expect(lines[2]).toContain('Bob');
+      expect(lines[2]).toContain('200');
+      expect(lines[3]).toContain('Charlie');
+      expect(lines[3]).toContain('300');
+    });
+
+    it('can download as CSV stream', async () => {
+      const stream = await sheet.downloadAsCSV(true);
+      expect(stream).toBeTruthy();
+      expect(typeof (stream as ReadableStream).getReader).toBe('function');
+    });
+
+    it('can download as TSV', async () => {
+      const buffer = await sheet.downloadAsTSV();
+      expect(buffer).toBeInstanceOf(ArrayBuffer);
+      expect(buffer.byteLength).toBeGreaterThan(0);
+
+      const tsvText = new TextDecoder().decode(buffer);
+      // TSV uses tabs
+      expect(tsvText).toContain('\t');
+      expect(tsvText).toContain('Alice');
+    });
+
+    it('can download as PDF', async () => {
+      const buffer = await sheet.downloadAsPDF();
+      expect(buffer).toBeInstanceOf(ArrayBuffer);
+      expect(buffer.byteLength).toBeGreaterThan(0);
+    });
+  });
+});