@an5/adapters 0.2.0 → 0.2.2

package/typescript/an5Adapter.js

@@ -7,10 +7,6 @@ const googlesheets_1 = require("./googlesheets");
 const parseConnectionString_1 = require("./googlesheets/parseConnectionString");
 const sql_1 = require("./base/sql");
 const metadata_1 = require("./base/metadata");
-const mssql_1 = require("./mssql");
-const postgres_1 = require("./postgres");
-const mysql_1 = require("./mysql");
-const sqlite_1 = require("./sqlite");
 var metadata_2 = require("./base/metadata");
 Object.defineProperty(exports, "setAdapterMetadata", { enumerable: true, get: function () { return metadata_2.setAdapterMetadata; } });
 function isSheetsConfig(config) {
@@ -18,9 +14,23 @@ function isSheetsConfig(config) {
 }
 // ─── An5Adapter ────────────────────────────────────────────────────────────────────
 class An5Adapter {
-    get dialect() { return this.sheetsAdapter ? 'googlesheets' : this.requireEngine().dialect; }
+    get dialect() {
+        if (this.sheetsAdapter)
+            return 'googlesheets';
+        if (this._engine)
+            return this._engine.dialect;
+        if (this._engineType === 'postgres')
+            return 'postgres';
+        if (this._engineType === 'mysql')
+            return 'mysql';
+        if (this._engineType === 'sqlite')
+            return 'sqlite';
+        return 'mssql';
+    }
     constructor(adapterConfig) {
-        this.engine = null;
+        this._engine = null;
+        this._engineType = null;
+        this._engineConfig = null;
         this.sheetsAdapter = null;
         if (isSheetsConfig(adapterConfig)) {
             this.sheetsAdapter = new googlesheets_1.An5SheetsAdapter(adapterConfig);
@@ -31,23 +41,48 @@ class An5Adapter {
             this.sheetsAdapter = new googlesheets_1.An5SheetsAdapter((0, parseConnectionString_1.parseSheetsConnectionString)(cs));
             return;
         }
+        this._engineConfig = adapterConfig;
         if (cs.startsWith('postgres://') || cs.startsWith('postgresql://')) {
-            this.engine = new postgres_1.PostgresEngine(adapterConfig);
+            this._engineType = 'postgres';
         }
         else if (cs.startsWith('mysql://') || cs.startsWith('mariadb://')) {
-            this.engine = new mysql_1.MysqlEngine(adapterConfig);
+            this._engineType = 'mysql';
         }
         else if (cs.startsWith('sqlite://') || cs.endsWith('.sqlite') || cs.endsWith('.db')) {
-            this.engine = new sqlite_1.SqliteEngine(adapterConfig);
+            this._engineType = 'sqlite';
         }
         else {
-            this.engine = new mssql_1.MssqlEngine(adapterConfig);
+            this._engineType = 'mssql';
         }
     }
-    requireEngine() {
-        if (!this.engine)
+    async requireEngine() {
+        if (!this._engine && this._engineType) {
+            switch (this._engineType) {
+                case 'postgres': {
+                    const { PostgresEngine } = require('./postgres.js');
+                    this._engine = new PostgresEngine(this._engineConfig);
+                    break;
+                }
+                case 'mysql': {
+                    const { MysqlEngine } = require('./mysql.js');
+                    this._engine = new MysqlEngine(this._engineConfig);
+                    break;
+                }
+                case 'sqlite': {
+                    const { SqliteEngine } = require('./sqlite.js');
+                    this._engine = new SqliteEngine(this._engineConfig);
+                    break;
+                }
+                case 'mssql': {
+                    const { MssqlEngine } = require('./mssql.js');
+                    this._engine = new MssqlEngine(this._engineConfig);
+                    break;
+                }
+            }
+        }
+        if (!this._engine)
             throw new Error('SQL engine is not available for Google Sheets adapter');
-        return this.engine;
+        return this._engine;
     }
     requireSheetsAdapter() {
         if (!this.sheetsAdapter)
@@ -57,19 +92,19 @@ class An5Adapter {
     async exec(query, params) {
         if (this.sheetsAdapter)
             return this.sheetsAdapter.exec(query, params);
-        return this.requireEngine().exec(query, params);
+        return (await this.requireEngine()).exec(query, params);
     }
     /** INTERNAL: used by AdapterTableClient for DML statements needing row count */
     async _executeRaw(query, params) {
-        return this.requireEngine().executeRaw(query, params);
+        return (await this.requireEngine()).executeRaw(query, params);
     }
     /** Execute a raw query with positional values → @p_0, @p_1, ... per dialect */
     async $queryRawUnsafe(query, ...values) {
         if (this.sheetsAdapter)
             return this.sheetsAdapter.$queryRawUnsafe(query, ...values);
+        const engine = await this.requireEngine();
         const params = {};
         values.forEach((v, i) => { params[`p_${i}`] = v; });
-        // Normalise external positional placeholders → @p_N so each engine can re-transform
         let q = query;
         if (this.dialect === 'postgres') {
             let idx = 0;
@@ -79,11 +114,12 @@ class An5Adapter {
             let idx = 0;
             q = q.replace(/\?/g, () => `@p_${idx++}`);
         }
-        return this.exec(q, params);
+        return engine.exec(q, params);
     }
     async $executeRaw(query, ...values) {
         if (this.sheetsAdapter)
             return this.sheetsAdapter.$executeRaw(query, ...values);
+        const engine = await this.requireEngine();
         const params = {};
         values.forEach((v, i) => { params[`p_${i}`] = v; });
         let q = query;
@@ -95,7 +131,7 @@ class An5Adapter {
             let idx = 0;
             q = q.replace(/\?/g, () => `@p_${idx++}`);
         }
-        return this.requireEngine().executeRaw(q, params);
+        return engine.executeRaw(q, params);
     }
     async $executeRawUnsafe(query, ...values) {
         return this.$executeRaw(query, ...values);
@@ -103,19 +139,20 @@ class An5Adapter {
     async $connect() {
         if (this.sheetsAdapter)
             return this.sheetsAdapter.$connect();
-        await this.requireEngine().connect();
+        await (await this.requireEngine()).connect();
     }
     async $disconnect() {
         if (this.sheetsAdapter)
             return this.sheetsAdapter.$disconnect();
-        await this.requireEngine().disconnect();
+        await (await this.requireEngine()).disconnect();
     }
     async $transaction(fn, _options) {
         if (this.sheetsAdapter)
             return this.sheetsAdapter.$transaction(fn, _options);
         if (Array.isArray(fn))
             return Promise.all(fn);
-        const handle = await this.requireEngine().beginTransaction();
+        const engine = await this.requireEngine();
+        const handle = await engine.beginTransaction();
         const txAdapter = new An5AdapterTx(handle, this.dialect);
         try {
             const result = await fn(txAdapter);

package/typescript/browser.d.ts

@@ -0,0 +1,5 @@
+export { An5SheetsAdapter, SheetsTableClient, createAn5SheetsAdapter } from './googlesheets';
+export type { An5SheetsAdapterConfig } from './googlesheets';
+export type { An5AdapterConfig, Dialect } from './base/types';
+export { getFieldsForModel, getModelToTable, setAdapterMetadata } from './base/metadata';
+export type { AdapterMetadata } from './base/metadata';

package/typescript/browser.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAdapterMetadata = exports.getModelToTable = exports.getFieldsForModel = exports.createAn5SheetsAdapter = exports.SheetsTableClient = exports.An5SheetsAdapter = void 0;
+// Browser-safe entry — no SQL engine imports
+var googlesheets_1 = require("./googlesheets");
+Object.defineProperty(exports, "An5SheetsAdapter", { enumerable: true, get: function () { return googlesheets_1.An5SheetsAdapter; } });
+Object.defineProperty(exports, "SheetsTableClient", { enumerable: true, get: function () { return googlesheets_1.SheetsTableClient; } });
+Object.defineProperty(exports, "createAn5SheetsAdapter", { enumerable: true, get: function () { return googlesheets_1.createAn5SheetsAdapter; } });
+var metadata_1 = require("./base/metadata");
+Object.defineProperty(exports, "getFieldsForModel", { enumerable: true, get: function () { return metadata_1.getFieldsForModel; } });
+Object.defineProperty(exports, "getModelToTable", { enumerable: true, get: function () { return metadata_1.getModelToTable; } });
+Object.defineProperty(exports, "setAdapterMetadata", { enumerable: true, get: function () { return metadata_1.setAdapterMetadata; } });

package/typescript/googlesheets/adapter.d.ts

@@ -1,13 +1,14 @@
-import { sheets_v4 } from 'googleapis';
 import { An5SheetsAdapterConfig, resolveConfig } from './config';
 import { SheetsTableClient } from './tableClient';
 import { SheetMeta } from './types';
 export declare class An5SheetsAdapter {
     private sheets;
+    private fetchApi;
     config: ReturnType<typeof resolveConfig>;
     private sheetsCache;
     constructor(config: An5SheetsAdapterConfig);
-    getSheets(): Promise<sheets_v4.Sheets>;
+    private get isOAuth();
+    getSheets(): Promise<any>;
     private getApi;
     invalidateCache(): void;
     listSheets(): Promise<string[]>;

package/typescript/googlesheets/adapter.js

@@ -2,26 +2,95 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.An5SheetsAdapter = void 0;
 exports.createAn5SheetsAdapter = createAn5SheetsAdapter;
-const googleapis_1 = require("googleapis");
 const config_1 = require("./config");
 const sqlExecutor_1 = require("./sqlExecutor");
 const tableClient_1 = require("./tableClient");
 const retry_1 = require("./retry");
+// ─── Fetch-based API proxy for OAuth Access Token (browser-compatible) ────────
+function createFetchApi(spreadsheetId, accessToken) {
+    const base = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}`;
+    const headers = { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' };
+    async function request(method, path, body) {
+        const url = path.startsWith('http') ? path : `${base}${path}`;
+        const opts = { 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.status = res.status;
+            err.body = text;
+            const retryAfter = res.headers.get('Retry-After');
+            if (retryAfter)
+                err.retryAfter = parseInt(retryAfter, 10);
+            throw err;
+        }
+        const text = await res.text();
+        return text ? JSON.parse(text) : undefined;
+    }
+    function fmtRange(range) {
+        return `/${encodeURIComponent(range)}`;
+    }
+    return {
+        spreadsheets: {
+            get: async (params) => {
+                const data = await request('GET', `?fields=${params.fields || ''}`);
+                return { data };
+            },
+            batchUpdate: async (params) => {
+                const data = await request('POST', ':batchUpdate', params.requestBody);
+                return { data };
+            },
+            values: {
+                get: async (params) => {
+                    const data = await request('GET', fmtRange(params.range));
+                    return { data };
+                },
+                update: async (params) => {
+                    const qs = `?valueInputOption=${params.valueInputOption || 'RAW'}`;
+                    const data = await request('PUT', `${fmtRange(params.range)}${qs}`, params.requestBody);
+                    return { data };
+                },
+                append: async (params) => {
+                    const qs = `?valueInputOption=${params.valueInputOption || 'RAW'}&insertDataOption=${params.insertDataOption || 'INSERT_ROWS'}`;
+                    await request('POST', `${fmtRange(params.range)}:append${qs}`, params.requestBody);
+                    return { data: { updates: { updatedRows: (params.requestBody?.values || []).length } } };
+                },
+                clear: async (params) => {
+                    await request('POST', `${fmtRange(params.range)}:clear`);
+                    return { data: {} };
+                },
+            },
+        },
+    };
+}
 // ─── Adapter ──────────────────────────────────────────────────────────────────
 class An5SheetsAdapter {
     constructor(config) {
         this.sheets = null;
+        this.fetchApi = null;
         this.sheetsCache = null;
         this.config = (0, config_1.resolveConfig)(config);
     }
+    get isOAuth() {
+        return !!this.config.accessToken;
+    }
     async getSheets() {
+        if (this.isOAuth) {
+            if (!this.fetchApi) {
+                this.fetchApi = createFetchApi(this.config.spreadsheetId, this.config.accessToken);
+            }
+            return this.fetchApi;
+        }
         if (!this.sheets) {
-            const auth = new googleapis_1.google.auth.JWT({
+            const { google } = await import('googleapis');
+            const auth = new google.auth.JWT({
                 email: this.config.clientEmail,
                 key: this.config.privateKey,
                 scopes: ['https://www.googleapis.com/auth/spreadsheets'],
             });
-            this.sheets = googleapis_1.google.sheets({ version: 'v4', auth });
+            this.sheets = google.sheets({ version: 'v4', auth });
         }
         return this.sheets;
     }
@@ -37,7 +106,7 @@ class An5SheetsAdapter {
             spreadsheetId: this.config.spreadsheetId,
             fields: 'sheets.properties.title',
         }));
-        return (res.data.sheets || []).map(s => s.properties?.title || '');
+        return (res.data.sheets || []).map((s) => s.properties?.title || '');
     }
     async getSheetMeta(name) {
         const api = await this.getApi();
@@ -47,14 +116,14 @@ class An5SheetsAdapter {
                     spreadsheetId: this.config.spreadsheetId,
                     fields: 'sheets.properties',
                 });
-                return (res.data.sheets || []).map(s => ({
+                return (res.data.sheets || []).map((s) => ({
                     sheetId: s.properties?.sheetId ?? -1,
                     title: s.properties?.title ?? '',
-                })).filter(m => m.sheetId >= 0);
+                })).filter((m) => m.sheetId >= 0);
             });
         }
         const all = await this.sheetsCache;
-        return all.find(m => m.title === name) || null;
+        return all.find((m) => m.title === name) || null;
     }
     async deleteSheet(name) {
         const meta = await this.getSheetMeta(name);
@@ -74,6 +143,7 @@ class An5SheetsAdapter {
     }
     async $disconnect() {
         this.sheets = null;
+        this.fetchApi = null;
         this.sheetsCache = null;
     }
     async exec(query, params) {

package/typescript/googlesheets/an5SheetsAdapter.d.ts

@@ -1,3 +1,3 @@
 export { An5SheetsAdapter, createAn5SheetsAdapter } from './adapter';
 export { SheetsTableClient } from './tableClient';
-export { An5SheetsAdapterConfig } from './config';
+export type { An5SheetsAdapterConfig } from './config';

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/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/index.d.ts

@@ -1,2 +1,3 @@
-export { An5SheetsAdapter, SheetsTableClient, createAn5SheetsAdapter, An5SheetsAdapterConfig } from './an5SheetsAdapter';
+export { An5SheetsAdapter, SheetsTableClient, createAn5SheetsAdapter } from './an5SheetsAdapter';
+export type { An5SheetsAdapterConfig } from './an5SheetsAdapter';
 export { parseSheetsConnectionString } from './parseConnectionString';

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/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/index.d.ts

@@ -1,2 +1,4 @@
-export { An5Adapter, AdapterTableClient, createAn5Adapter, setAdapterMetadata, An5AdapterConfig, AdapterMetadata, Dialect, } from './an5Adapter';
-export { getLlmConfig, setLlmConfig, getEmbeddingConfig, setEmbeddingConfig, resetAdapter, LlmConfigData, EmbeddingConfigData, } from './config';
+export { An5Adapter, AdapterTableClient, createAn5Adapter, setAdapterMetadata, } from './an5Adapter';
+export type { An5AdapterConfig, AdapterMetadata, Dialect, } from './an5Adapter';
+export { getLlmConfig, setLlmConfig, getEmbeddingConfig, setEmbeddingConfig, resetAdapter, } from './config';
+export type { LlmConfigData, EmbeddingConfigData, } from './config';