@an5/adapters 0.1.3 → 0.2.1

package/python/table_client.py

@@ -1,219 +1,216 @@
-import json
-import uuid
-from typing import Dict, List, Optional
-try:
-    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, model_fields, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table
-except ImportError:
-    from base import DIALECT_MSSQL, DIALECT_POSTGRES, model_fields, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table
-
-# ─── Table Client ───────────────────────────────────────────────────────────────────
-
-class AdapterTableClient:
-    def __init__(self, adapter: An5Adapter, model_name: str):
-        self._adapter = adapter
-        self._model = model_name
-        self._dialect = adapter._dialect
-
-    @property
-    def _table(self) -> str:
-        return _resolve_table(self._model)
-
-    @property
-    def _table_sql(self) -> str:
-        return _quote_table(self._table, self._dialect)
-
-    @property
-    def _nolock(self) -> str:
-        return "" if self._dialect == DIALECT_POSTGRES else " WITH (NOLOCK)"
-
-    @property
-    def _fields(self) -> List[Dict]:
-        fields = model_fields.get(self._model, [])
-        if isinstance(fields, dict):
-            normalized = []
-            for name, value in fields.items():
-                if isinstance(value, dict):
-                    normalized.append({"name": name, **value})
-                else:
-                    normalized.append({"name": name, "type": value})
-            return normalized
-        return fields
-
-    def _pagination(self, take: Optional[int], skip: int, order_sql: str) -> str:
-        if take is None:
-            return ""
-        if self._dialect == DIALECT_POSTGRES:
-            return f" LIMIT {take} OFFSET {skip}"
-        order_prefix = "" if order_sql else " ORDER BY (SELECT NULL)"
-        return f"{order_prefix} OFFSET {skip} ROWS FETCH NEXT {take} ROWS ONLY"
-
-    def find_many(self, where=None, order_by=None, skip: int = 0, take: Optional[int] = None, select=None) -> List[Dict]:
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect)
-        order_sql = _build_order_by(order_by, self._dialect)
-
-        query = f"SELECT * FROM {self._table_sql}{self._nolock}"
-        if where_sql:
-            query += f" WHERE {where_sql}"
-        if order_sql:
-            query += f" {order_sql}"
-        query += self._pagination(take, skip, order_sql)
-        return self._adapter.exec(query, list(params.values()))
-
-    def find_first(self, where=None, order_by=None, select=None) -> Optional[Dict]:
-        rows = self.find_many(where=where, order_by=order_by, take=1, select=select)
-        return rows[0] if rows else None
-
-    def find_unique(self, where: Dict) -> Optional[Dict]:
-        return self.find_first(where=where)
-
-    def count(self, where=None) -> int:
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect)
-        query = f"SELECT COUNT(*) AS cnt FROM {self._table_sql}{self._nolock}"
-        if where_sql:
-            query += f" WHERE {where_sql}"
-        rows = self._adapter.exec(query, list(params.values()))
-        return int(rows[0]["cnt"]) if rows else 0
-
-    def create(self, data: Dict) -> Dict:
-        id_field = next((f for f in self._fields if f.get("isId")), None)
-        if id_field and id_field["name"] not in data:
-            data = {**data, id_field["name"]: str(uuid.uuid4())}
-
-        cols = [k for k, v in data.items() if v is not None]
-        values = [data[c] for c in cols]
-        placeholders = ", ".join(["?" if self._dialect == DIALECT_MSSQL else "%s"] * len(cols))
-        col_list = ", ".join(_quote(c, self._dialect) for c in cols)
-        query = f"INSERT INTO {self._table_sql} ({col_list}) VALUES ({placeholders})"
-        self._adapter.execute(query, values)
-
-        if id_field:
-            return self.find_first(where={id_field["name"]: data[id_field["name"]]}) or data
-        return data
-
-    def create_many(self, data: List[Dict], skip_duplicates: bool = False) -> Dict:
-        count = 0
-        for row in data:
-            try:
-                self.create(row)
-                count += 1
-            except Exception:
-                if not skip_duplicates:
-                    raise
-        return {"count": count}
-
-    def update(self, where: Dict, data: Dict) -> Optional[Dict]:
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect, "w_")
-        set_parts: List[str] = []
-        set_values: List = []
-        placeholder = "?" if self._dialect == DIALECT_MSSQL else "%s"
-        for col, val in data.items():
-            if val is not None:
-                set_parts.append(f"{_quote(col, self._dialect)} = {placeholder}")
-                set_values.append(val)
-
-        all_values = set_values + list(params.values())
-        query = f"UPDATE {self._table_sql} SET {', '.join(set_parts)}"
-        if where_sql:
-            query += f" WHERE {where_sql}"
-        self._adapter.execute(query, all_values)
-        return self.find_first(where=where)
-
-    def update_many(self, where: Optional[Dict], data: Dict) -> Dict:
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect, "w_")
-        set_parts: List[str] = []
-        set_values: List = []
-        placeholder = "?" if self._dialect == DIALECT_MSSQL else "%s"
-        for col, val in data.items():
-            set_parts.append(f"{_quote(col, self._dialect)} = {placeholder}")
-            set_values.append(val)
-        all_values = set_values + list(params.values())
-        query = f"UPDATE {self._table_sql} SET {', '.join(set_parts)}"
-        if where_sql:
-            query += f" WHERE {where_sql}"
-        count = self._adapter.execute(query, all_values)
-        return {"count": count}
-
-    def delete(self, where: Dict) -> Optional[Dict]:
-        existing = self.find_first(where=where)
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect)
-        query = f"DELETE FROM {self._table_sql} WHERE {where_sql}"
-        self._adapter.execute(query, list(params.values()))
-        return existing
-
-    def delete_many(self, where: Optional[Dict] = None) -> Dict:
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect)
-        query = f"DELETE FROM {self._table_sql}"
-        if where_sql:
-            query += f" WHERE {where_sql}"
-        count = self._adapter.execute(query, list(params.values()))
-        return {"count": count}
-
-    def upsert(self, where: Dict, create: Dict, update: Dict) -> Dict:
-        existing = self.find_first(where=where)
-        if existing:
-            return self.update(where=where, data=update) or existing
-        return self.create(data=create)
-
-    def aggregate(self, where=None, _count=None, _sum=None, _avg=None, _min=None, _max=None) -> Dict:
-        params: Dict = {}
-        where_sql = _parse_where(self._model, where, params, self._dialect)
-        aggs: List[str] = []
-        if _count:
-            aggs.append("COUNT(*) AS _count")
-        if _sum:
-            for f in (_sum if isinstance(_sum, list) else [_sum]):
-                aggs.append(f"SUM({_quote(f, self._dialect)}) AS _sum_{f}")
-        if _avg:
-            for f in (_avg if isinstance(_avg, list) else [_avg]):
-                aggs.append(f"AVG({_quote(f, self._dialect)}) AS _avg_{f}")
-        if _min:
-            for f in (_min if isinstance(_min, list) else [_min]):
-                aggs.append(f"MIN({_quote(f, self._dialect)}) AS _min_{f}")
-        if _max:
-            for f in (_max if isinstance(_max, list) else [_max]):
-                aggs.append(f"MAX({_quote(f, self._dialect)}) AS _max_{f}")
-        if not aggs:
-            aggs = ["COUNT(*) AS _count"]
-
-        query = f"SELECT {', '.join(aggs)} FROM {self._table_sql}"
-        if where_sql:
-            query += f" WHERE {where_sql}"
-        rows = self._adapter.exec(query, list(params.values()))
-        return rows[0] if rows else {}
-
-    def vector_search(self, vector: List[float], take: int = 10, where=None, vector_field: str = "embedding", distance_metric: str = "cosine") -> List[Dict]:
-        rows = self.find_many(where=where)
-        scored = []
-        for row in rows:
-            raw = row.get(vector_field)
-            if raw is None:
-                continue
-            try:
-                vec = json.loads(raw) if isinstance(raw, str) else list(raw)
-            except Exception:
-                continue
-            if not vec or len(vec) != len(vector):
-                continue
-
-            dot = sum(a * b for a, b in zip(vector, vec))
-            m1 = sum(a ** 2 for a in vector) ** 0.5
-            m2 = sum(b ** 2 for b in vec) ** 0.5
-            cosine = dot / (m1 * m2) if m1 and m2 else 0.0
-
-            if distance_metric == "cosine":
-                dist = 1.0 - cosine
-            elif distance_metric == "dot":
-                dist = -dot
-            else:
-                dist = sum((a - b) ** 2 for a, b in zip(vector, vec)) ** 0.5
-
-            scored.append((row, dist))
-
-        scored.sort(key=lambda x: x[1])
-        return [{**row, "distance": dist} for row, dist in scored[:take]]
+import json
+import uuid
+from typing import Dict, List, Optional
+try:
+    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, model_fields, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table
+except ImportError:
+    from base import DIALECT_MSSQL, DIALECT_POSTGRES, model_fields, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table
+
+# ─── Table Client ───────────────────────────────────────────────────────────────────
+
+class AdapterTableClient:
+    def __init__(self, adapter: An5Adapter, model_name: str):
+        self._adapter = adapter
+        self._model = model_name
+        self._dialect = adapter._dialect
+
+    @property
+    def _table(self) -> str:
+        return _resolve_table(self._model)
+
+    @property
+    def _table_sql(self) -> str:
+        return _quote_table(self._table, self._dialect)
+
+    @property
+    def _nolock(self) -> str:
+        return "" if self._dialect == DIALECT_POSTGRES else " WITH (NOLOCK)"
+
+    @property
+    def _fields(self) -> List[Dict]:
+        fields = model_fields.get(self._model, [])
+        if isinstance(fields, dict):
+            raise TypeError(
+                "AN5 Python metadata is out of date. Regenerate with @an5/orm >= 1.0.4 "
+                "so MODEL_FIELDS uses a list of field objects."
+            )
+        return fields
+
+    def _pagination(self, take: Optional[int], skip: int, order_sql: str) -> str:
+        if take is None:
+            return ""
+        if self._dialect == DIALECT_POSTGRES:
+            return f" LIMIT {take} OFFSET {skip}"
+        order_prefix = "" if order_sql else " ORDER BY (SELECT NULL)"
+        return f"{order_prefix} OFFSET {skip} ROWS FETCH NEXT {take} ROWS ONLY"
+
+    def find_many(self, where=None, order_by=None, skip: int = 0, take: Optional[int] = None, select=None) -> List[Dict]:
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect)
+        order_sql = _build_order_by(order_by, self._dialect)
+
+        query = f"SELECT * FROM {self._table_sql}{self._nolock}"
+        if where_sql:
+            query += f" WHERE {where_sql}"
+        if order_sql:
+            query += f" {order_sql}"
+        query += self._pagination(take, skip, order_sql)
+        return self._adapter.exec(query, list(params.values()))
+
+    def find_first(self, where=None, order_by=None, select=None) -> Optional[Dict]:
+        rows = self.find_many(where=where, order_by=order_by, take=1, select=select)
+        return rows[0] if rows else None
+
+    def find_unique(self, where: Dict) -> Optional[Dict]:
+        return self.find_first(where=where)
+
+    def count(self, where=None) -> int:
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect)
+        query = f"SELECT COUNT(*) AS cnt FROM {self._table_sql}{self._nolock}"
+        if where_sql:
+            query += f" WHERE {where_sql}"
+        rows = self._adapter.exec(query, list(params.values()))
+        return int(rows[0]["cnt"]) if rows else 0
+
+    def create(self, data: Dict) -> Dict:
+        id_field = next((f for f in self._fields if f.get("isId")), None)
+        if id_field and id_field["name"] not in data:
+            data = {**data, id_field["name"]: str(uuid.uuid4())}
+
+        cols = [k for k, v in data.items() if v is not None]
+        values = [data[c] for c in cols]
+        placeholders = ", ".join(["?" if self._dialect == DIALECT_MSSQL else "%s"] * len(cols))
+        col_list = ", ".join(_quote(c, self._dialect) for c in cols)
+        query = f"INSERT INTO {self._table_sql} ({col_list}) VALUES ({placeholders})"
+        self._adapter.execute(query, values)
+
+        if id_field:
+            return self.find_first(where={id_field["name"]: data[id_field["name"]]}) or data
+        return data
+
+    def create_many(self, data: List[Dict], skip_duplicates: bool = False) -> Dict:
+        count = 0
+        for row in data:
+            try:
+                self.create(row)
+                count += 1
+            except Exception:
+                if not skip_duplicates:
+                    raise
+        return {"count": count}
+
+    def update(self, where: Dict, data: Dict) -> Optional[Dict]:
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect, "w_")
+        set_parts: List[str] = []
+        set_values: List = []
+        placeholder = "?" if self._dialect == DIALECT_MSSQL else "%s"
+        for col, val in data.items():
+            if val is not None:
+                set_parts.append(f"{_quote(col, self._dialect)} = {placeholder}")
+                set_values.append(val)
+
+        all_values = set_values + list(params.values())
+        query = f"UPDATE {self._table_sql} SET {', '.join(set_parts)}"
+        if where_sql:
+            query += f" WHERE {where_sql}"
+        self._adapter.execute(query, all_values)
+        return self.find_first(where=where)
+
+    def update_many(self, where: Optional[Dict], data: Dict) -> Dict:
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect, "w_")
+        set_parts: List[str] = []
+        set_values: List = []
+        placeholder = "?" if self._dialect == DIALECT_MSSQL else "%s"
+        for col, val in data.items():
+            set_parts.append(f"{_quote(col, self._dialect)} = {placeholder}")
+            set_values.append(val)
+        all_values = set_values + list(params.values())
+        query = f"UPDATE {self._table_sql} SET {', '.join(set_parts)}"
+        if where_sql:
+            query += f" WHERE {where_sql}"
+        count = self._adapter.execute(query, all_values)
+        return {"count": count}
+
+    def delete(self, where: Dict) -> Optional[Dict]:
+        existing = self.find_first(where=where)
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect)
+        query = f"DELETE FROM {self._table_sql} WHERE {where_sql}"
+        self._adapter.execute(query, list(params.values()))
+        return existing
+
+    def delete_many(self, where: Optional[Dict] = None) -> Dict:
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect)
+        query = f"DELETE FROM {self._table_sql}"
+        if where_sql:
+            query += f" WHERE {where_sql}"
+        count = self._adapter.execute(query, list(params.values()))
+        return {"count": count}
+
+    def upsert(self, where: Dict, create: Dict, update: Dict) -> Dict:
+        existing = self.find_first(where=where)
+        if existing:
+            return self.update(where=where, data=update) or existing
+        return self.create(data=create)
+
+    def aggregate(self, where=None, _count=None, _sum=None, _avg=None, _min=None, _max=None) -> Dict:
+        params: Dict = {}
+        where_sql = _parse_where(self._model, where, params, self._dialect)
+        aggs: List[str] = []
+        if _count:
+            aggs.append("COUNT(*) AS _count")
+        if _sum:
+            for f in (_sum if isinstance(_sum, list) else [_sum]):
+                aggs.append(f"SUM({_quote(f, self._dialect)}) AS _sum_{f}")
+        if _avg:
+            for f in (_avg if isinstance(_avg, list) else [_avg]):
+                aggs.append(f"AVG({_quote(f, self._dialect)}) AS _avg_{f}")
+        if _min:
+            for f in (_min if isinstance(_min, list) else [_min]):
+                aggs.append(f"MIN({_quote(f, self._dialect)}) AS _min_{f}")
+        if _max:
+            for f in (_max if isinstance(_max, list) else [_max]):
+                aggs.append(f"MAX({_quote(f, self._dialect)}) AS _max_{f}")
+        if not aggs:
+            aggs = ["COUNT(*) AS _count"]
+
+        query = f"SELECT {', '.join(aggs)} FROM {self._table_sql}"
+        if where_sql:
+            query += f" WHERE {where_sql}"
+        rows = self._adapter.exec(query, list(params.values()))
+        return rows[0] if rows else {}
+
+    def vector_search(self, vector: List[float], take: int = 10, where=None, vector_field: str = "embedding", distance_metric: str = "cosine") -> List[Dict]:
+        rows = self.find_many(where=where)
+        scored = []
+        for row in rows:
+            raw = row.get(vector_field)
+            if raw is None:
+                continue
+            try:
+                vec = json.loads(raw) if isinstance(raw, str) else list(raw)
+            except Exception:
+                continue
+            if not vec or len(vec) != len(vector):
+                continue
+
+            dot = sum(a * b for a, b in zip(vector, vec))
+            m1 = sum(a ** 2 for a in vector) ** 0.5
+            m2 = sum(b ** 2 for b in vec) ** 0.5
+            cosine = dot / (m1 * m2) if m1 and m2 else 0.0
+
+            if distance_metric == "cosine":
+                dist = 1.0 - cosine
+            elif distance_metric == "dot":
+                dist = -dot
+            else:
+                dist = sum((a - b) ** 2 for a, b in zip(vector, vec)) ** 0.5
+
+            scored.append((row, dist))
+
+        scored.sort(key=lambda x: x[1])
+        return [{**row, "distance": dist} for row, dist in scored[:take]]

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

@@ -7,14 +7,83 @@ 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({
                 email: this.config.clientEmail,
@@ -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) {