@an5/adapters 0.1.3 → 0.2.1

package/typescript/googlesheets/adapter.ts

@@ -5,10 +5,73 @@ import { SheetsTableClient } from './tableClient';
 import { SheetMeta } from './types';
 import { withRetry } from './retry';
 
+// ─── Fetch-based API proxy for OAuth Access Token (browser-compatible) ────────
+
+function createFetchApi(spreadsheetId: string, accessToken: string) {
+  const base = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}`;
+  const headers = { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' };
+
+  async function request<T>(method: string, path: string, body?: any): Promise<T> {
+    const url = path.startsWith('http') ? path : `${base}${path}`;
+    const opts: RequestInit = { method, headers };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(url, opts);
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      const err = new Error(`Google Sheets API error (${res.status}): ${text}`);
+      (err as any).status = res.status;
+      (err as any).body = text;
+      const retryAfter = res.headers.get('Retry-After');
+      if (retryAfter) (err as any).retryAfter = parseInt(retryAfter, 10);
+      throw err;
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : (undefined as T);
+  }
+
+  function fmtRange(range: string): string {
+    return `/${encodeURIComponent(range)}`;
+  }
+
+  return {
+    spreadsheets: {
+      get: async (params: any) => {
+        const data = await request<any>('GET', `?fields=${params.fields || ''}`);
+        return { data };
+      },
+      batchUpdate: async (params: any) => {
+        const data = await request<any>('POST', ':batchUpdate', params.requestBody);
+        return { data };
+      },
+      values: {
+        get: async (params: any) => {
+          const data = await request<any>('GET', fmtRange(params.range));
+          return { data };
+        },
+        update: async (params: any) => {
+          const qs = `?valueInputOption=${params.valueInputOption || 'RAW'}`;
+          const data = await request<any>('PUT', `${fmtRange(params.range)}${qs}`, params.requestBody);
+          return { data };
+        },
+        append: async (params: any) => {
+          const qs = `?valueInputOption=${params.valueInputOption || 'RAW'}&insertDataOption=${params.insertDataOption || 'INSERT_ROWS'}`;
+          await request<any>('POST', `${fmtRange(params.range)}:append${qs}`, params.requestBody);
+          return { data: { updates: { updatedRows: (params.requestBody?.values || []).length } } };
+        },
+        clear: async (params: any) => {
+          await request<any>('POST', `${fmtRange(params.range)}:clear`);
+          return { data: {} };
+        },
+      },
+    },
+  };
+}
+
 // ─── Adapter ──────────────────────────────────────────────────────────────────
 
 export class An5SheetsAdapter {
   private sheets: sheets_v4.Sheets | null = null;
+  private fetchApi: ReturnType<typeof createFetchApi> | null = null;
   config: ReturnType<typeof resolveConfig>;
   private sheetsCache: Promise<SheetMeta[]> | null = null;
 
@@ -16,7 +79,17 @@ export class An5SheetsAdapter {
     this.config = resolveConfig(config);
   }
 
-  async getSheets(): Promise<sheets_v4.Sheets> {
+  private get isOAuth(): boolean {
+    return !!(this.config as any).accessToken;
+  }
+
+  async getSheets(): Promise<any> {
+    if (this.isOAuth) {
+      if (!this.fetchApi) {
+        this.fetchApi = createFetchApi(this.config.spreadsheetId, (this.config as any).accessToken);
+      }
+      return this.fetchApi;
+    }
     if (!this.sheets) {
       const auth = new google.auth.JWT({
         email: this.config.clientEmail,
@@ -38,31 +111,31 @@ export class An5SheetsAdapter {
 
   async listSheets(): Promise<string[]> {
     const api = await this.getApi();
-    const res = await withRetry(() =>
+    const res: any = await withRetry(() =>
       api.spreadsheets.get({
         spreadsheetId: this.config.spreadsheetId,
         fields: 'sheets.properties.title',
       })
     );
-    return (res.data.sheets || []).map(s => s.properties?.title || '');
+    return (res.data.sheets || []).map((s: any) => s.properties?.title || '');
   }
 
   async getSheetMeta(name: string): Promise<SheetMeta | null> {
     const api = await this.getApi();
     if (this.sheetsCache == null) {
       this.sheetsCache = withRetry(async () => {
-        const res = await api.spreadsheets.get({
+        const res: any = await api.spreadsheets.get({
           spreadsheetId: this.config.spreadsheetId,
           fields: 'sheets.properties',
         });
-        return (res.data.sheets || []).map(s => ({
+        return (res.data.sheets || []).map((s: any) => ({
           sheetId: s.properties?.sheetId ?? -1,
           title: s.properties?.title ?? '',
-        })).filter(m => m.sheetId >= 0);
+        })).filter((m: SheetMeta) => m.sheetId >= 0);
       });
     }
     const all = await this.sheetsCache;
-    return all.find(m => m.title === name) || null;
+    return all.find((m: SheetMeta) => m.title === name) || null;
   }
 
   async deleteSheet(name: string): Promise<void> {
@@ -86,6 +159,7 @@ export class An5SheetsAdapter {
 
   async $disconnect(): Promise<void> {
     this.sheets = null;
+    this.fetchApi = null;
     this.sheetsCache = null;
   }
 
@@ -126,7 +200,7 @@ export class An5SheetsAdapter {
 
   async readRange<T = any>(range: string): Promise<T[][]> {
     const api = await this.getApi();
-    const res = await withRetry(() =>
+    const res: any = await withRetry(() =>
       api.spreadsheets.values.get({
         spreadsheetId: this.config.spreadsheetId,
         range,

package/typescript/googlesheets/config.d.ts

@@ -7,11 +7,22 @@ export interface An5SheetsAdapterConfig {
         private_key: string;
     };
     sheetMapping?: Record<string, string>;
+    /** OAuth2 access token for browser-based authentication (e.g. from Firebase Auth Google sign-in).
+     * When provided, the adapter uses raw fetch() instead of googleapis JWT, making it compatible
+     * with browser environments. Mutually exclusive with clientEmail/privateKey/credentials. */
+    accessToken?: string;
 }
 export declare function normalizeKey(key: string): string;
 export declare function resolveConfig(config: An5SheetsAdapterConfig): {
+    spreadsheetId: string;
+    accessToken: string;
+    sheetMapping: Record<string, string> | undefined;
+    clientEmail?: undefined;
+    privateKey?: undefined;
+} | {
     spreadsheetId: string;
     clientEmail: string;
     privateKey: string;
     sheetMapping: Record<string, string> | undefined;
+    accessToken?: undefined;
 };

package/typescript/googlesheets/config.js

@@ -12,6 +12,13 @@ function normalizeKey(key) {
     return `-----BEGIN PRIVATE KEY-----\n${lines}\n-----END PRIVATE KEY-----`;
 }
 function resolveConfig(config) {
+    if (config.accessToken) {
+        return {
+            spreadsheetId: config.spreadsheetId,
+            accessToken: config.accessToken,
+            sheetMapping: config.sheetMapping,
+        };
+    }
     if (config.credentials) {
         return {
             spreadsheetId: config.spreadsheetId,

package/typescript/googlesheets/config.ts

@@ -6,6 +6,10 @@ export interface An5SheetsAdapterConfig {
   privateKey?: string;
   credentials?: { client_email: string; private_key: string };
   sheetMapping?: Record<string, string>;
+  /** OAuth2 access token for browser-based authentication (e.g. from Firebase Auth Google sign-in).
+   * When provided, the adapter uses raw fetch() instead of googleapis JWT, making it compatible
+   * with browser environments. Mutually exclusive with clientEmail/privateKey/credentials. */
+  accessToken?: string;
 }
 
 export function normalizeKey(key: string): string {
@@ -16,6 +20,13 @@ export function normalizeKey(key: string): string {
 }
 
 export function resolveConfig(config: An5SheetsAdapterConfig) {
+  if (config.accessToken) {
+    return {
+      spreadsheetId: config.spreadsheetId,
+      accessToken: config.accessToken,
+      sheetMapping: config.sheetMapping,
+    };
+  }
   if (config.credentials) {
     return {
       spreadsheetId: config.spreadsheetId,

package/typescript/googlesheets/helpers.js

@@ -95,7 +95,7 @@ function buildOrderBy(orderBy) {
     const parts = [];
     for (const entry of entries) {
         for (const [key, dir] of Object.entries(entry)) {
-            parts.push(`${key} ${dir.toUpperCase()}`);
+            parts.push(`${key} ${String(dir || 'asc').toUpperCase()}`);
         }
     }
     return parts.join(', ');

package/typescript/googlesheets/helpers.ts

@@ -75,7 +75,7 @@ export function buildOrderBy(orderBy: any): string {
   const parts: string[] = [];
   for (const entry of entries) {
     for (const [key, dir] of Object.entries(entry)) {
-      parts.push(`${key} ${(dir as string).toUpperCase()}`);
+      parts.push(`${key} ${String(dir || 'asc').toUpperCase()}`);
     }
   }
   return parts.join(', ');

package/typescript/googlesheets/retry.js

@@ -5,19 +5,32 @@ exports.BASE_DELAY = exports.MAX_RETRIES = void 0;
 exports.withRetry = withRetry;
 exports.MAX_RETRIES = 3;
 exports.BASE_DELAY = 1000;
+function isRateLimitError(err) {
+    const code = err?.code || err?.status || err?.response?.status;
+    if (code === 429)
+        return true;
+    if (code === 500 || code === 503)
+        return true;
+    if (code === 403) {
+        const reason = err?.errors?.[0]?.reason || '';
+        if (reason === 'rateLimitExceeded')
+            return true;
+        if (typeof err?.body === 'string' && err.body.includes('rateLimitExceeded'))
+            return true;
+        if (typeof err?.message === 'string' && err.message.includes('rateLimitExceeded'))
+            return true;
+    }
+    return false;
+}
 async function withRetry(fn, attempt = 1) {
     try {
         return await fn();
     }
     catch (err) {
-        const code = err?.code || err?.status || err?.response?.status;
-        if ((code === 429 || code === 500 || code === 503) && attempt <= exports.MAX_RETRIES) {
-            const delay = exports.BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 500;
-            await new Promise(r => setTimeout(r, delay));
-            return withRetry(fn, attempt + 1);
-        }
-        if (code === 403 && err?.errors?.[0]?.reason === 'rateLimitExceeded' && attempt <= exports.MAX_RETRIES) {
-            const delay = exports.BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 500;
+        if (isRateLimitError(err) && attempt <= exports.MAX_RETRIES) {
+            const delay = err.retryAfter
+                ? err.retryAfter * 1000
+                : exports.BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 500;
             await new Promise(r => setTimeout(r, delay));
             return withRetry(fn, attempt + 1);
         }

package/typescript/googlesheets/retry.ts

@@ -3,18 +3,27 @@
 export const MAX_RETRIES = 3;
 export const BASE_DELAY = 1000;
 
+function isRateLimitError(err: any): boolean {
+  const code = err?.code || err?.status || err?.response?.status;
+  if (code === 429) return true;
+  if (code === 500 || code === 503) return true;
+  if (code === 403) {
+    const reason = err?.errors?.[0]?.reason || '';
+    if (reason === 'rateLimitExceeded') return true;
+    if (typeof err?.body === 'string' && err.body.includes('rateLimitExceeded')) return true;
+    if (typeof err?.message === 'string' && err.message.includes('rateLimitExceeded')) return true;
+  }
+  return false;
+}
+
 export async function withRetry<T>(fn: () => Promise<T>, attempt = 1): Promise<T> {
   try {
     return await fn();
   } catch (err: any) {
-    const code = err?.code || err?.status || err?.response?.status;
-    if ((code === 429 || code === 500 || code === 503) && attempt <= MAX_RETRIES) {
-      const delay = BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 500;
-      await new Promise(r => setTimeout(r, delay));
-      return withRetry(fn, attempt + 1);
-    }
-    if (code === 403 && err?.errors?.[0]?.reason === 'rateLimitExceeded' && attempt <= MAX_RETRIES) {
-      const delay = BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 500;
+    if (isRateLimitError(err) && attempt <= MAX_RETRIES) {
+      const delay = err.retryAfter
+        ? err.retryAfter * 1000
+        : BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 500;
       await new Promise(r => setTimeout(r, delay));
       return withRetry(fn, attempt + 1);
     }

package/typescript/googlesheets/tableClient.js

@@ -315,13 +315,14 @@ class SheetsTableClient {
             result._count = rows.length;
         if (args._sum) {
             for (const f of Object.keys(args._sum)) {
-                result[`_sum_${f}`] = rows.reduce((s, r) => s + (Number(r[f]) || 0), 0);
+                const nums = rows.map((r) => Number(r[f])).filter(n => !isNaN(n));
+                result[`_sum_${f}`] = nums.length > 0 ? nums.reduce((s, n) => s + n, 0) : null;
             }
         }
         if (args._avg) {
             for (const f of Object.keys(args._avg)) {
-                const sum = rows.reduce((s, r) => s + (Number(r[f]) || 0), 0);
-                result[`_avg_${f}`] = rows.length > 0 ? sum / rows.length : 0;
+                const nums = rows.map((r) => Number(r[f])).filter(n => !isNaN(n));
+                result[`_avg_${f}`] = nums.length > 0 ? nums.reduce((s, n) => s + n, 0) / nums.length : null;
             }
         }
         if (args._min) {

package/typescript/googlesheets/tableClient.ts

@@ -43,7 +43,7 @@ export class SheetsTableClient<T = any> {
 
   private async readAllRows(): Promise<{ headers: string[]; rows: Record<string, any>[] }> {
     const api = await this.adapter.getSheets();
-    const res = await withRetry(() =>
+    const res: any = await withRetry(() =>
       api.spreadsheets.values.get({
         spreadsheetId: this.adapter.config.spreadsheetId,
         range: `${this.escSheetName}!A:ZZ`,
@@ -68,7 +68,7 @@ export class SheetsTableClient<T = any> {
     const api = await this.adapter.getSheets();
     await this.ensureSheetExists();
 
-    const res = await withRetry(() =>
+    const res: any = await withRetry(() =>
       api.spreadsheets.values.get({
         spreadsheetId: this.adapter.config.spreadsheetId,
         range: `${this.escSheetName}!A1:ZZ1`,
@@ -351,13 +351,14 @@ export class SheetsTableClient<T = any> {
     if (args._count !== undefined) result._count = rows.length;
     if (args._sum) {
       for (const f of Object.keys(args._sum)) {
-        result[`_sum_${f}`] = rows.reduce((s, r: any) => s + (Number(r[f]) || 0), 0);
+        const nums = rows.map((r: any) => Number(r[f])).filter(n => !isNaN(n));
+        result[`_sum_${f}`] = nums.length > 0 ? nums.reduce((s, n) => s + n, 0) : null;
       }
     }
     if (args._avg) {
       for (const f of Object.keys(args._avg)) {
-        const sum = rows.reduce((s, r: any) => s + (Number(r[f]) || 0), 0);
-        result[`_avg_${f}`] = rows.length > 0 ? sum / rows.length : 0;
+        const nums = rows.map((r: any) => Number(r[f])).filter(n => !isNaN(n));
+        result[`_avg_${f}`] = nums.length > 0 ? nums.reduce((s, n) => s + n, 0) / nums.length : null;
       }
     }
     if (args._min) {