@an5/adapters 0.1.0

package/dotnet/Mssql/MssqlEngine.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Reflection;
+
+namespace An5Orm
+{
+// ─── MSSQL Engine ──────────────────────────────────────────────────────────
+
+    internal class MssqlEngine : IQueryEngine
+    {
+        public Dialect Dialect => Dialect.Mssql;
+        private readonly string _connectionString;
+        private readonly int _commandTimeout;
+
+        [ThreadStatic] private static System.Data.SqlClient.SqlConnection _txConn;
+        [ThreadStatic] private static System.Data.SqlClient.SqlTransaction _tx;
+
+        public MssqlEngine(string connectionString, int commandTimeout)
+        {
+            _connectionString = connectionString;
+            _commandTimeout = commandTimeout;
+        }
+
+        private System.Data.SqlClient.SqlConnection OpenConnection(out bool isInTransaction)
+        {
+            if (_txConn != null) { isInTransaction = true; return _txConn; }
+            isInTransaction = false;
+            var conn = new System.Data.SqlClient.SqlConnection(_connectionString);
+            conn.Open();
+            return conn;
+        }
+
+        private System.Data.SqlClient.SqlCommand BuildCommand(
+            System.Data.SqlClient.SqlConnection conn, string sql, Dictionary<string, object> parameters)
+        {
+            var cmd = new System.Data.SqlClient.SqlCommand(sql, conn) { CommandTimeout = _commandTimeout };
+            if (_tx != null) cmd.Transaction = _tx;
+            if (parameters != null)
+            {
+                foreach (var kv in parameters)
+                {
+                    var paramName = kv.Key.StartsWith("@") ? kv.Key : "@" + kv.Key;
+                    cmd.Parameters.AddWithValue(paramName, kv.Value ?? DBNull.Value);
+                }
+            }
+            return cmd;
+        }
+
+        public List<Dictionary<string, object>> QueryRaw(string sql, Dictionary<string, object> parameters)
+        {
+            var results = new List<Dictionary<string, object>>();
+            var conn = OpenConnection(out bool isTx);
+            try
+            {
+                using var cmd = BuildCommand(conn, sql, parameters);
+                using var reader = cmd.ExecuteReader();
+                while (reader.Read())
+                {
+                    var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                    for (int i = 0; i < reader.FieldCount; i++)
+                    {
+                        row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                    }
+                    results.Add(row);
+                }
+            }
+            finally { if (!isTx) conn.Dispose(); }
+            return results;
+        }
+
+        public List<T> QueryRaw<T>(string sql, Dictionary<string, object> parameters) where T : new()
+        {
+            var results = new List<T>();
+            var conn = OpenConnection(out bool isTx);
+            try
+            {
+                using var cmd = BuildCommand(conn, sql, parameters);
+                using var reader = cmd.ExecuteReader();
+                var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+                while (reader.Read())
+                {
+                    var item = new T();
+                    foreach (var prop in props)
+                    {
+                        if (!HasColumn(reader, prop.Name)) continue;
+                        var val = reader[prop.Name];
+                        if (val == DBNull.Value) continue;
+                        try { prop.SetValue(item, Convert.ChangeType(val, prop.PropertyType)); } catch { }
+                    }
+                    results.Add(item);
+                }
+            }
+            finally { if (!isTx) conn.Dispose(); }
+            return results;
+        }
+
+        public int ExecuteRaw(string sql, Dictionary<string, object> parameters)
+        {
+            var conn = OpenConnection(out bool isTx);
+            try
+            {
+                using var cmd = BuildCommand(conn, sql, parameters);
+                return cmd.ExecuteNonQuery();
+            }
+            finally { if (!isTx) conn.Dispose(); }
+        }
+
+        private static bool HasColumn(System.Data.SqlClient.SqlDataReader reader, string name)
+        {
+            for (int i = 0; i < reader.FieldCount; i++)
+                if (reader.GetName(i).Equals(name, StringComparison.OrdinalIgnoreCase)) return true;
+            return false;
+        }
+
+        public An5TransactionBase BeginTransaction()
+        {
+            var conn = new System.Data.SqlClient.SqlConnection(_connectionString);
+            conn.Open();
+            var tx = conn.BeginTransaction();
+            _txConn = conn;
+            _tx = tx;
+            return new MssqlTransaction(conn, tx, () => { _txConn = null; _tx = null; });
+        }
+    }
+
+    internal class MssqlTransaction : An5TransactionBase
+    {
+        private readonly System.Data.SqlClient.SqlConnection _conn;
+        private readonly System.Data.SqlClient.SqlTransaction _tx;
+        private readonly Action _cleanup;
+
+        public MssqlTransaction(System.Data.SqlClient.SqlConnection conn, System.Data.SqlClient.SqlTransaction tx, Action cleanup)
+        {
+            _conn = conn;
+            _tx = tx;
+            _cleanup = cleanup;
+        }
+
+        public override void Commit() { _tx.Commit(); _cleanup(); }
+        public override void Rollback() { _tx.Rollback(); _cleanup(); }
+        public override void Dispose() { _tx.Dispose(); _conn.Dispose(); _cleanup(); }
+    }
+}

package/dotnet/Postgres/PostgresEngine.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Reflection;
+
+namespace An5Orm
+{
+// ─── PostgreSQL Engine ─────────────────────────────────────────────────────
+
+    internal class PostgresEngine : IQueryEngine
+    {
+        public Dialect Dialect => Dialect.Postgres;
+        private readonly string _connectionString;
+        private readonly int _commandTimeout;
+
+        public PostgresEngine(string connectionString, int commandTimeout)
+        {
+            _connectionString = connectionString;
+            _commandTimeout = commandTimeout;
+        }
+
+        private Npgsql.NpgsqlConnection OpenConnection()
+        {
+            var conn = new Npgsql.NpgsqlConnection(_connectionString);
+            conn.Open();
+            return conn;
+        }
+
+        private Npgsql.NpgsqlCommand BuildCommand(
+            Npgsql.NpgsqlConnection conn, string sql, Dictionary<string, object> parameters)
+        {
+            var cmd = new Npgsql.NpgsqlCommand(sql, conn) { CommandTimeout = _commandTimeout };
+            if (parameters != null)
+            {
+                foreach (var kv in parameters)
+                {
+                    var paramName = kv.Key.StartsWith("@") ? kv.Key : "@" + kv.Key;
+                    cmd.Parameters.AddWithValue(paramName, kv.Value ?? DBNull.Value);
+                }
+            }
+            return cmd;
+        }
+
+        public List<Dictionary<string, object>> QueryRaw(string sql, Dictionary<string, object> parameters)
+        {
+            var results = new List<Dictionary<string, object>>();
+            using var conn = OpenConnection();
+            using var cmd = BuildCommand(conn, sql, parameters);
+            using var reader = cmd.ExecuteReader();
+            while (reader.Read())
+            {
+                var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                for (int i = 0; i < reader.FieldCount; i++)
+                {
+                    row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                }
+                results.Add(row);
+            }
+            return results;
+        }
+
+        public List<T> QueryRaw<T>(string sql, Dictionary<string, object> parameters) where T : new()
+        {
+            var results = new List<T>();
+            using var conn = OpenConnection();
+            using var cmd = BuildCommand(conn, sql, parameters);
+            using var reader = cmd.ExecuteReader();
+            var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            while (reader.Read())
+            {
+                var item = new T();
+                foreach (var prop in props)
+                {
+                    if (!HasColumn(reader, prop.Name)) continue;
+                    var val = reader[prop.Name];
+                    if (val == DBNull.Value) continue;
+                    try { prop.SetValue(item, Convert.ChangeType(val, prop.PropertyType)); } catch { }
+                }
+                results.Add(item);
+            }
+            return results;
+        }
+
+        public int ExecuteRaw(string sql, Dictionary<string, object> parameters)
+        {
+            using var conn = OpenConnection();
+            using var cmd = BuildCommand(conn, sql, parameters);
+            return cmd.ExecuteNonQuery();
+        }
+
+        private static bool HasColumn(Npgsql.NpgsqlDataReader reader, string name)
+        {
+            for (int i = 0; i < reader.FieldCount; i++)
+                if (reader.GetName(i).Equals(name, StringComparison.OrdinalIgnoreCase)) return true;
+            return false;
+        }
+
+        public An5TransactionBase BeginTransaction()
+        {
+            var conn = OpenConnection();
+            var tx = conn.BeginTransaction();
+            return new PostgresTransaction(conn, tx);
+        }
+    }
+
+    internal class PostgresTransaction : An5TransactionBase
+    {
+        private readonly Npgsql.NpgsqlConnection _conn;
+        private readonly Npgsql.NpgsqlTransaction _tx;
+
+        public PostgresTransaction(Npgsql.NpgsqlConnection conn, Npgsql.NpgsqlTransaction tx)
+        {
+            _conn = conn;
+            _tx = tx;
+        }
+
+        public override void Commit() { _tx.Commit(); }
+        public override void Rollback() { _tx.Rollback(); }
+        public override void Dispose() { _tx.Dispose(); _conn.Dispose(); }
+    }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@an5/adapters",
+  "version": "0.1.0",
+  "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET query execution.",
+  "license": "MIT",
+  "main": "typescript/index.js",
+  "types": "typescript/index.d.ts",
+  "exports": {
+    ".": "./typescript/index.js",
+    "./typescript": "./typescript/index.js",
+    "./typescript/*": "./typescript/*",
+    "./python": "./python/an5_adapter.py",
+    "./dotnet": "./dotnet/An5Adapter.cs",
+    "./config": "./typescript/config.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/an5ORM/an5Adapters.git"
+  },
+  "keywords": ["an5", "orm", "adapter", "typescript", "python", "dotnet"],
+  "files": [
+    "typescript/**/*.{ts,js,d.ts}",
+    "python/**/*.py",
+    "dotnet/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node test/unit.test.js",
+    "test:python": "python -m compileall python 2>&1"
+  },
+  "dependencies": {
+    "googleapis": "^134.0.0",
+    "mssql": "^12.5.5",
+    "pg": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/mssql": "^9.1.8",
+    "@types/node": "^20.11.0",
+    "@types/pg": "^8.11.0",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/python/an5_adapter.py

@@ -0,0 +1,97 @@
+"""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",
+]

package/python/base/__init__.py

@@ -0,0 +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

package/python/base/dialects.py

@@ -0,0 +1,8 @@
+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

package/python/base/metadata.py

@@ -0,0 +1,9 @@
+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:
+    global model_to_table, model_fields
+    model_to_table = dict(metadata.get("model_to_table") or metadata.get("modelToTable") or {})
+    model_fields = dict(metadata.get("model_fields") or metadata.get("modelFields") or {})

package/python/base/sql.py

@@ -0,0 +1,121 @@
+from typing import Any, Dict, List, Optional
+from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES
+from .metadata import model_to_table, model_fields
+
+# ─── Quoting ───────────────────────────────────────────────────────────────────────
+
+def _quote(name: str, dialect: str) -> str:
+    if dialect == DIALECT_POSTGRES:
+        if name.startswith("[") and name.endswith("]"):
+            return f'"{name[1:-1]}"'
+        return f'"{name}"'
+    return name if name.startswith("[") else f"[{name}]"
+
+
+# ─── Connection helpers live in provider modules ────────────────────────────────
+
+# ─── Where clause builder ──────────────────────────────────────────────────────────
+
+def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect: str, prefix: str = "") -> str:
+    if not where:
+        return ""
+    conditions: List[str] = []
+
+    for key, value in where.items():
+        if key == "OR" and isinstance(value, list):
+            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}or{i}_") for i, v in enumerate(value)]
+            sub = [s for s in sub if s]
+            if sub:
+                conditions.append(f"({' OR '.join(sub)})")
+        elif key == "AND" and isinstance(value, list):
+            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}and{i}_") for i, v in enumerate(value)]
+            sub = [s for s in sub if s]
+            if sub:
+                conditions.append(f"({' AND '.join(sub)})")
+        else:
+            col = _quote(key, dialect)
+            pname = f"{prefix}{key}"
+            placeholder = "%s" if dialect == DIALECT_POSTGRES else "?"
+            if value is None:
+                conditions.append(f"{col} IS NULL")
+            elif isinstance(value, dict):
+                if "not" in value:
+                    if value["not"] is None:
+                        conditions.append(f"{col} IS NOT NULL")
+                    else:
+                        params[f"{pname}_not"] = value["not"]
+                        conditions.append(f"{col} <> {placeholder}")
+                if "equals" in value:
+                    params[f"{pname}_eq"] = value["equals"]
+                    conditions.append(f"{col} = {placeholder}")
+                if "contains" in value:
+                    params[f"{pname}_co"] = f"%{value['contains']}%"
+                    conditions.append(f"{col} LIKE {placeholder}")
+                if "startsWith" in value:
+                    params[f"{pname}_sw"] = f"{value['startsWith']}%"
+                    conditions.append(f"{col} LIKE {placeholder}")
+                if "endsWith" in value:
+                    params[f"{pname}_ew"] = f"%{value['endsWith']}"
+                    conditions.append(f"{col} LIKE {placeholder}")
+                if "gte" in value:
+                    params[f"{pname}_gte"] = value["gte"]
+                    conditions.append(f"{col} >= {placeholder}")
+                if "lte" in value:
+                    params[f"{pname}_lte"] = value["lte"]
+                    conditions.append(f"{col} <= {placeholder}")
+                if "gt" in value:
+                    params[f"{pname}_gt"] = value["gt"]
+                    conditions.append(f"{col} > {placeholder}")
+                if "lt" in value:
+                    params[f"{pname}_lt"] = value["lt"]
+                    conditions.append(f"{col} < {placeholder}")
+                if "in" in value:
+                    vals = value["in"]
+                    if vals:
+                        placeholders = ", ".join([placeholder] * len(vals))
+                        for i, v in enumerate(vals):
+                            params[f"{pname}_in{i}"] = v
+                        conditions.append(f"{col} IN ({placeholders})")
+                    else:
+                        conditions.append("1=0")
+            else:
+                params[pname] = value
+                conditions.append(f"{col} = {placeholder}")
+
+    return " AND ".join(conditions)
+
+
+def _build_order_by(order_by: Any, dialect: str) -> str:
+    if not order_by:
+        return ""
+    entries = order_by if isinstance(order_by, list) else [order_by]
+    parts: List[str] = []
+    for entry in entries:
+        for col, direction in entry.items():
+            parts.append(f"{_quote(col, dialect)} {str(direction).upper()}")
+    return f"ORDER BY {', '.join(parts)}" if parts else ""
+
+
+# ─── Table name resolution ─────────────────────────────────────────────────────────
+
+def _resolve_table(model_name: str) -> str:
+    if model_name in model_to_table:
+        return model_to_table[model_name]
+    camel = model_name[0].lower() + model_name[1:] if model_name else model_name
+    if camel in model_to_table:
+        return model_to_table[camel]
+    lower = model_name.lower()
+    if lower in model_to_table:
+        return model_to_table[lower]
+    return model_name
+
+
+def _quote_table(t: str, dialect: str) -> str:
+    q = lambda s: f'"{s}"' if dialect == DIALECT_POSTGRES else f"[{s}]"
+    if t.startswith("[") or t.startswith('"'):
+        return t
+    if "." in t:
+        return ".".join(q(p) for p in t.split("."))
+    return q(t)
+
+

package/python/mssql/__init__.py

@@ -0,0 +1 @@
+from .provider import PYODBC_AVAILABLE, connect, parse_connection_string, placeholder

package/python/mssql/provider.py

@@ -0,0 +1,62 @@
+try:
+    import pyodbc
+    PYODBC_AVAILABLE = True
+except ImportError:
+    pyodbc = None
+    PYODBC_AVAILABLE = False
+
+def parse_connection_string(url: str) -> str:
+    """Convert sqlserver:// URL to pyodbc connection string."""
+    url = url.replace("sqlserver://", "")
+    parts = url.split(";")
+    host_part = parts[0]
+    host, _, port = host_part.partition(":")
+    port = port or "1433"
+
+    config: Dict[str, str] = {"server": host, "port": port}
+    for part in parts[1:]:
+        if "=" not in part:
+            continue
+        k, _, v = part.partition("=")
+        k = k.strip().lower()
+        v = v.strip()
+        if k in ("database",):
+            config["database"] = v
+        elif k in ("user", "uid"):
+            config["user"] = v
+        elif k in ("password", "pwd"):
+            config["password"] = v
+        elif k == "encrypt":
+            config["encrypt"] = "yes" if v.lower() == "true" else "no"
+        elif k == "trustservercertificate":
+            config["trust"] = "yes" if v.lower() == "true" else "no"
+
+    encrypt = config.get("encrypt", "yes")
+    trust = config.get("trust", "yes")
+    if "user" in config:
+        return (
+            f"DRIVER={{ODBC Driver 17 for SQL Server}};"
+            f"SERVER={config['server']},{config['port']};"
+            f"DATABASE={config.get('database', '')};"
+            f"UID={config['user']};"
+            f"PWD={config.get('password', '')};"
+            f"Encrypt={encrypt};TrustServerCertificate={trust};"
+        )
+    # Windows auth
+    return (
+        f"DRIVER={{ODBC Driver 17 for SQL Server}};"
+        f"SERVER={config['server']},{config['port']};"
+        f"DATABASE={config.get('database', '')};"
+        f"Trusted_Connection=yes;"
+        f"Encrypt={encrypt};TrustServerCertificate={trust};"
+    )
+
+
+
+def connect(connection_string: str):
+    if not PYODBC_AVAILABLE:
+        raise ImportError("pyodbc is required: pip install pyodbc")
+    return pyodbc.connect(parse_connection_string(connection_string), autocommit=True)
+
+def placeholder() -> str:
+    return "?"

package/python/postgres/__init__.py

@@ -0,0 +1 @@
+from .provider import PSYCOPG2_AVAILABLE, connect, placeholder

package/python/postgres/provider.py

@@ -0,0 +1,15 @@
+try:
+    import psycopg2
+    import psycopg2.extras
+    PSYCOPG2_AVAILABLE = True
+except ImportError:
+    psycopg2 = None
+    PSYCOPG2_AVAILABLE = False
+
+def connect(connection_string: str):
+    if not PSYCOPG2_AVAILABLE:
+        raise ImportError("psycopg2 is required: pip install psycopg2-binary")
+    return psycopg2.connect(connection_string)
+
+def placeholder() -> str:
+    return "%s"