@an5/adapters 0.2.5 → 0.2.9

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.9",
+  "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET, Go, Rust, and Google Sheets query execution.",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,10 @@
     "./typescript": "./dist/index.js",
     "./typescript/*": "./dist/*",
     "./python": "./python/an5_adapter.py",
-    "./dotnet": "./dotnet/An5Adapter.cs"
+    "./dotnet": "./dotnet/An5Adapter.cs",
+    "./golang": "./golang/an5_adapter.go",
+    "./rust": "./rust/Cargo.toml",
+    "./nbase": "./dist/nbase/index.js"
   },
   "author": "an5ORM",
   "homepage": "https://github.com/an5ORM/an5",
@@ -34,20 +37,34 @@
     "adapter",
     "typescript",
     "python",
-    "dotnet"
+    "dotnet",
+    "go",
+    "golang",
+    "rust"
   ],
   "files": [
     "dist/**/*.{js,d.ts}",
     "typescript/src/**/*.ts",
     "python/**/*.py",
     "dotnet/**/*",
-    "README.md"
+    "golang/**/*",
+    "rust/Cargo.toml",
+    "rust/src/**/*",
+    "README.md",
+    "typescript/src/nbase/**/*.ts"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "build:python": "python -m build --outdir dist-py",
-    "test": "node test/unit.test.js && node test/package.test.js",
-    "test:python": "python -m compileall python 2>&1"
+    "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 && node test/nbase.test.js && node --test test/version-sync.test.js",
+    "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 && node scripts/dotnet-sqlite-smoke.js",
+    "test:go": "cd golang && go test ./...",
+    "test:rust": "node scripts/rust-compile-check.js"
   },
   "dependencies": {
     "googleapis": "^134.0.0",
@@ -58,7 +75,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,184 @@
-"""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, DIALECT_SQLITE, detect_dialect, set_adapter_metadata
+    from .mssql import connect as connect_mssql
+    from .postgres import connect as connect_postgres
+    from .sqlite import connect as connect_sqlite, is_memory as is_sqlite_memory
+    from .table_client import AdapterTableClient, ViewClient
+except ImportError:
+    from base import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE, detect_dialect, set_adapter_metadata
+    from mssql import connect as connect_mssql
+    from postgres import connect as connect_postgres
+    from sqlite import connect as connect_sqlite, is_memory as is_sqlite_memory
+    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
+        # The open connection of `transaction()`, when there is one. Every
+        # statement in the callback has to use this very connection, otherwise a
+        # rollback returns to a different, already committed connection — that
+        # is "the error was raised but the data is still there".
+        self._txn_conn = None
+        # Long-lived connection for in-memory databases, because `:memory:` is
+        # gone as soon as every connection is closed.
+        self._conn = None
+
+    def _connect(self):
+        if self._dialect == DIALECT_POSTGRES:
+            return connect_postgres(self._conn_str)
+        if self._dialect == DIALECT_SQLITE:
+            return connect_sqlite(self._conn_str)
+        return connect_mssql(self._conn_str)
+
+    def _acquire(self):
+        """Returns (connection, whether we opened it and must close it)."""
+        if self._txn_conn is not None:
+            return self._txn_conn, False
+        if self._dialect == DIALECT_SQLITE and is_sqlite_memory(self._conn_str):
+            if self._conn is None:
+                self._conn = self._connect()
+            return self._conn, False
+        return self._connect(), True
+
+    def close(self):
+        """Closes the long-lived connection (in-memory databases only)."""
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+    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, owned = self._acquire()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params or [])
+            return self._to_dicts(cursor, query)
+        finally:
+            if owned:
+                conn.close()
+
+    def execute(self, query: str, params: Optional[List] = None) -> int:
+        conn, owned = self._acquire()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, params or [])
+            return cursor.rowcount
+        finally:
+            if owned:
+                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_SQLITE:
+            # SQLite has no stored procedures. This used to fall through to the
+            # MSSQL branch and generate `EXEC ...`, which is not valid SQL, and
+            # the error only surfaced at the call. Saying so beats sending wrong
+            # SQL.
+            raise NotImplementedError(
+                "SQLite has no stored procedures. Use the generated table client "
+                "(db.<model>.*) or db.exec() with a parameterised query."
+            )
+        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_SQLITE:
+            raise NotImplementedError(
+                "SQLite has no stored procedures. Use the generated table client "
+                "(db.<model>.*) or db.execute() with a parameterised query."
+            )
+        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):
+        if self._txn_conn is not None:
+            raise RuntimeError("Nested transaction() is not supported")
+        # In-memory database: the connection holding the data has to be reused.
+        # Opening a new one here points at a different, empty database — the
+        # table just created disappears and every statement in the transaction
+        # fails.
+        conn = self._conn if self._conn is not None else self._connect()
+        owned = self._conn is None
+        if self._dialect == DIALECT_SQLITE:
+            # `sqlite3.Connection` has no `autocommit` attribute; transactions
+            # are driven by `isolation_level`. The provider opens at `None`
+            # (autocommit), so to get a transaction it has to be set back to `""`
+            # and sqlite3 opens an implicit BEGIN before each DML statement —
+            # only then do `commit()`/`rollback()` do anything.
+            conn.isolation_level = ""
+        else:
+            conn.autocommit = False
+        self._txn_conn = conn
+        try:
+            result = fn(self)
+            conn.commit()
+            return result
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            self._txn_conn = None
+            if self._dialect == DIALECT_POSTGRES:
+                conn.autocommit = True
+            elif self._dialect == DIALECT_SQLITE:
+                conn.isolation_level = None
+            if owned:
+                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",
+    "DIALECT_SQLITE",
+    "_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, DIALECT_SQLITE, 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,59 @@
-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 resolve_model_key(model_name: str) -> str:
+    """The model name in the metadata, accepting a different capitalisation.
+
+    The generated client registers tables under their PascalCase name
+    (`CatalogType`) while the metadata keys them camelCase/snake_case
+    (`catalogType`, `catalog_type`). A plain lookup would find no columns at all
+    and silently skip `isId` — that is, never generate the primary key.
+    """
+    if not model_name:
+        return model_name
+    if model_name in model_to_table or model_name in model_fields:
+        return model_name
+    camel = model_name[0].lower() + model_name[1:]
+    if camel in model_to_table or camel in model_fields:
+        return camel
+    lower = model_name.lower()
+    if lower in model_to_table or lower in model_fields:
+        return lower
+    return model_name
+
+
+def get_relations_for_model(model_name: str) -> Dict[str, Dict[str, str]]:
+    return relation_map.get(model_name) or relation_map.get(resolve_model_key(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:
+    key = resolve_model_key(model_name)
+    if key in model_fields:
+        return model_fields[key]
+    return model_fields.get(model_name)