@an5/adapters 0.2.5 → 0.2.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@an5/adapters",
-  "version": "0.2.5",
-  "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET query execution.",
+  "version": "0.2.6",
+  "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET, Go, and Google Sheets query execution.",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,8 @@
     "./typescript": "./dist/index.js",
     "./typescript/*": "./dist/*",
     "./python": "./python/an5_adapter.py",
-    "./dotnet": "./dotnet/An5Adapter.cs"
+    "./dotnet": "./dotnet/An5Adapter.cs",
+    "./golang": "./golang/an5_adapter.go"
   },
   "author": "an5ORM",
   "homepage": "https://github.com/an5ORM/an5",
@@ -34,20 +35,29 @@
     "adapter",
     "typescript",
     "python",
-    "dotnet"
+    "dotnet",
+    "go",
+    "golang"
   ],
   "files": [
     "dist/**/*.{js,d.ts}",
     "typescript/src/**/*.ts",
     "python/**/*.py",
     "dotnet/**/*",
+    "golang/**/*",
     "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "build:python": "python -m build --outdir dist-py",
+    "pretest": "npm run build",
+    "prepack": "npm run build",
+    "build:python": "(python -m build --outdir dist-py || python3 -m build --outdir dist-py)",
     "test": "node test/unit.test.js && node test/package.test.js",
-    "test:python": "python -m compileall python 2>&1"
+    "test:package:smoke": "node scripts/package-smoke.js",
+    "test:integration:live": "node test/live-db.integration.test.js",
+    "test:python": "(python -m compileall python 2>&1 || python3 -m compileall python 2>&1)",
+    "test:dotnet": "node scripts/dotnet-compile-check.js",
+    "test:go": "cd golang && go test ./..."
   },
   "dependencies": {
     "googleapis": "^134.0.0",
@@ -58,7 +68,7 @@
     "@types/mssql": "^9.1.8",
     "@types/node": "^20.11.0",
     "@types/pg": "^8.11.0",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   },
   "publishConfig": {
     "access": "public"

package/python/an5_adapter.py

@@ -1,97 +1,119 @@
-"""Standalone Python runtime adapter for AN5 ORM."""
-
-from typing import Dict, List, Optional
-
-try:
-    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect, set_adapter_metadata
-    from .mssql import connect as connect_mssql
-    from .postgres import connect as connect_postgres
-    from .table_client import AdapterTableClient
-except ImportError:
-    from base import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect, set_adapter_metadata
-    from mssql import connect as connect_mssql
-    from postgres import connect as connect_postgres
-    from table_client import AdapterTableClient
-
-# Backward-compatible aliases used by tests and older imports.
-_detect_dialect = detect_dialect
-try:
-    from .mssql import parse_connection_string as _parse_connection_string
-except ImportError:
-    from mssql import parse_connection_string as _parse_connection_string
-
-class An5Adapter:
-    def __init__(self, connection_string: str):
-        self._dialect = detect_dialect(connection_string)
-        self._conn_str = connection_string
-
-    def _connect(self):
-        if self._dialect == DIALECT_POSTGRES:
-            return connect_postgres(self._conn_str)
-        return connect_mssql(self._conn_str)
-
-    def _to_dicts(self, cursor, query: str) -> List[Dict]:
-        if cursor.description:
-            cols = [col[0] for col in cursor.description]
-            rows = cursor.fetchall() if cursor.description else []
-            return [dict(zip(cols, row)) for row in rows]
-        return []
-
-    def exec(self, query: str, params: Optional[List] = None) -> List[Dict]:
-        conn = self._connect()
-        try:
-            cursor = conn.cursor()
-            cursor.execute(query, params or [])
-            return self._to_dicts(cursor, query)
-        finally:
-            conn.close()
-
-    def execute(self, query: str, params: Optional[List] = None) -> int:
-        conn = self._connect()
-        try:
-            cursor = conn.cursor()
-            cursor.execute(query, params or [])
-            return cursor.rowcount
-        finally:
-            conn.close()
-
-    def query_raw(self, query: str, *values) -> List[Dict]:
-        return self.exec(query, list(values))
-
-    def execute_raw(self, query: str, *values) -> int:
-        return self.execute(query, list(values))
-
-    def table(self, model_name: str) -> AdapterTableClient:
-        return AdapterTableClient(self, model_name)
-
-    def __getattr__(self, model_name: str) -> AdapterTableClient:
-        return self.table(model_name)
-
-    def transaction(self, fn):
-        conn = self._connect()
-        conn.autocommit = False
-        try:
-            result = fn(self)
-            conn.commit()
-            return result
-        except Exception:
-            conn.rollback()
-            raise
-        finally:
-            if self._dialect == DIALECT_POSTGRES:
-                conn.autocommit = True
-            conn.close()
-
-def create_an5_adapter(connection_string: str) -> An5Adapter:
-    return An5Adapter(connection_string)
-
-__all__ = [
-    "An5Adapter",
-    "AdapterTableClient",
-    "create_an5_adapter",
-    "DIALECT_MSSQL",
-    "DIALECT_POSTGRES",
-    "_detect_dialect",
-    "_parse_connection_string",
-    "set_adapter_metadata",
-]
+"""Standalone Python runtime adapter for AN5 ORM."""
+
+from typing import Dict, List, Optional, Any
+
+try:
+    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect, set_adapter_metadata
+    from .mssql import connect as connect_mssql
+    from .postgres import connect as connect_postgres
+    from .table_client import AdapterTableClient, ViewClient
+except ImportError:
+    from base import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect, set_adapter_metadata
+    from mssql import connect as connect_mssql
+    from postgres import connect as connect_postgres
+    from table_client import AdapterTableClient, ViewClient
+
+# Backward-compatible aliases used by tests and older imports.
+_detect_dialect = detect_dialect
+try:
+    from .mssql import parse_connection_string as _parse_connection_string
+except ImportError:
+    from mssql import parse_connection_string as _parse_connection_string
+
+class An5Adapter:
+    def __init__(self, connection_string: str):
+        self._dialect = detect_dialect(connection_string)
+        self._conn_str = connection_string
+
+    def _connect(self):
+        if self._dialect == DIALECT_POSTGRES:
+            return connect_postgres(self._conn_str)
+        return connect_mssql(self._conn_str)
+
+    def _to_dicts(self, cursor, query: str) -> List[Dict]:
+        if cursor.description:
+            cols = [col[0] for col in cursor.description]
+            rows = cursor.fetchall() if cursor.description else []
+            return [dict(zip(cols, row)) for row in rows]
+        return []
+
+    def exec(self, query: str, params: Optional[List] = None) -> List[Dict]:
+        conn = self._connect()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params or [])
+            return self._to_dicts(cursor, query)
+        finally:
+            conn.close()
+
+    def execute(self, query: str, params: Optional[List] = None) -> int:
+        conn = self._connect()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params or [])
+            return cursor.rowcount
+        finally:
+            conn.close()
+
+    def query_raw(self, query: str, *values) -> List[Dict]:
+        return self.exec(query, list(values))
+
+    def execute_raw(self, query: str, *values) -> int:
+        return self.execute(query, list(values))
+
+    def table(self, model_name: str) -> AdapterTableClient[Any]:
+        return AdapterTableClient(self, model_name)
+
+    def view(self, view_name: str) -> ViewClient:
+        return ViewClient(self, view_name)
+
+    def query_proc(self, proc_name: str, params: Optional[List] = None) -> List[Dict]:
+        if self._dialect == DIALECT_POSTGRES:
+            placeholders = ", ".join(["%s"] * len(params or []))
+            sql = f"CALL {proc_name}({placeholders})" if placeholders else f"CALL {proc_name}()"
+        else:
+            placeholders = ", ".join(["?"] * len(params or []))
+            sql = f"EXEC {proc_name} {placeholders}" if placeholders else f"EXEC {proc_name}"
+        return self.exec(sql, params or [])
+
+    def execute_proc(self, proc_name: str, params: Optional[List] = None) -> int:
+        if self._dialect == DIALECT_POSTGRES:
+            placeholders = ", ".join(["%s"] * len(params or []))
+            sql = f"CALL {proc_name}({placeholders})" if placeholders else f"CALL {proc_name}()"
+        else:
+            placeholders = ", ".join(["?"] * len(params or []))
+            sql = f"EXEC {proc_name} {placeholders}" if placeholders else f"EXEC {proc_name}"
+        return self.execute(sql, params or [])
+
+    def __getattr__(self, model_name: str) -> AdapterTableClient:
+        return self.table(model_name)
+
+    def transaction(self, fn):
+        conn = self._connect()
+        conn.autocommit = False
+        try:
+            result = fn(self)
+            conn.commit()
+            return result
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            if self._dialect == DIALECT_POSTGRES:
+                conn.autocommit = True
+            conn.close()
+
+def create_an5_adapter(connection_string: str) -> An5Adapter:
+    return An5Adapter(connection_string)
+
+__all__ = [
+    "An5Adapter",
+    "AdapterTableClient",
+    "ViewClient",
+    "create_an5_adapter",
+    "DIALECT_MSSQL",
+    "DIALECT_POSTGRES",
+    "_detect_dialect",
+    "_parse_connection_string",
+    "set_adapter_metadata",
+]

package/python/base/__init__.py

@@ -1,3 +1,3 @@
-from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect
-from .metadata import model_to_table, model_fields, set_adapter_metadata
-from .sql import _quote, _parse_where, _build_order_by, _resolve_table, _quote_table
+from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect
+from .metadata import model_to_table, model_fields, relation_map, set_adapter_metadata, get_relations_for_model, get_model_to_table, get_fields_for_model
+from .sql import _quote, _parse_where, _build_order_by, _resolve_table, _quote_table

package/python/base/dialects.py

@@ -1,8 +1,11 @@
-DIALECT_MSSQL = "mssql"
-DIALECT_POSTGRES = "postgres"
-
-def detect_dialect(connection_string: str) -> str:
-    cs = connection_string.strip().lower()
-    if cs.startswith("postgres://") or cs.startswith("postgresql://"):
-        return DIALECT_POSTGRES
-    return DIALECT_MSSQL
+DIALECT_MSSQL = "mssql"
+DIALECT_POSTGRES = "postgres"
+DIALECT_SQLITE = "sqlite"
+
+def detect_dialect(connection_string: str) -> str:
+    cs = connection_string.strip().lower()
+    if cs.startswith("postgres://") or cs.startswith("postgresql://"):
+        return DIALECT_POSTGRES
+    if cs.startswith("sqlite://") or cs.startswith("sqlite:") or cs.startswith("file:") or cs.endswith(".db") or cs.endswith(".sqlite") or cs.endswith(".sqlite3") or cs == ":memory:":
+        return DIALECT_SQLITE
+    return DIALECT_MSSQL

package/python/base/metadata.py

@@ -1,10 +1,35 @@
-from typing import Any, Dict
-
-model_to_table: Dict[str, str] = {}
-model_fields: Dict[str, Any] = {}
-
-def set_adapter_metadata(metadata: Dict[str, Any]) -> None:
-    model_to_table.clear()
-    model_to_table.update(metadata.get("model_to_table") or metadata.get("modelToTable") or {})
-    model_fields.clear()
-    model_fields.update(metadata.get("model_fields") or metadata.get("modelFields") or {})
+from typing import Any, Dict, List, Optional
+
+model_to_table: Dict[str, str] = {}
+model_fields: Dict[str, Any] = {}
+relation_map: Dict[str, Dict[str, Dict[str, str]]] = {}
+
+def set_adapter_metadata(metadata: Dict[str, Any]) -> None:
+    model_to_table.clear()
+    model_to_table.update(metadata.get("model_to_table") or metadata.get("modelToTable") or {})
+    model_fields.clear()
+    model_fields.update(metadata.get("model_fields") or metadata.get("modelFields") or {})
+    relation_map.clear()
+    rels = metadata.get("relation_map") or metadata.get("relationMap") or metadata.get("RELATION_MAP") or {}
+    if isinstance(rels, dict):
+        for model, relations in rels.items():
+            if not isinstance(relations, dict):
+                continue
+            relation_map[model] = {}
+            for key, defn in relations.items():
+                if isinstance(defn, dict):
+                    relation_map[model][key] = {
+                        "modelName": defn.get("modelName") or defn.get("model_name") or "",
+                        "relationType": defn.get("relationType") or defn.get("relation_type") or "many",
+                        "foreignKey": defn.get("foreignKey") or defn.get("foreign_key") or "",
+                        "localKey": defn.get("localKey") or defn.get("local_key") or "",
+                    }
+
+def get_relations_for_model(model_name: str) -> Dict[str, Dict[str, str]]:
+    return relation_map.get(model_name) or {}
+
+def get_model_to_table() -> Dict[str, str]:
+    return dict(model_to_table)
+
+def get_fields_for_model(model_name: str) -> Any:
+    return model_fields.get(model_name)