@an5/adapters 0.2.9 → 0.2.11

package/dist/googlesheets/oauth.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sheetsTokenProvider = sheetsTokenProvider;
+/** Deduplicate refresh requests within an adapter; do not expose token responses. */
+function sheetsTokenProvider(config) {
+    let token = config.accessToken;
+    let expiresAt = config.tokenExpiresAt;
+    let pending;
+    return async (force = false) => {
+        if (token && !force && (expiresAt === undefined || expiresAt > Date.now() + 60000))
+            return token;
+        if (!config.refreshToken || !config.oauthClientId) {
+            if (force || expiresAt !== undefined)
+                throw new Error('Google access expired. Reconnect your Google account.');
+            return token;
+        }
+        if (!pending)
+            pending = (async () => {
+                try {
+                    const response = await fetch('https://oauth2.googleapis.com/token', {
+                        method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                        body: new URLSearchParams({ grant_type: 'refresh_token', client_id: config.oauthClientId, refresh_token: config.refreshToken, ...(config.oauthClientSecret ? { client_secret: config.oauthClientSecret } : {}) }),
+                        signal: AbortSignal.timeout(20000),
+                    });
+                    if (!response.ok)
+                        throw new Error();
+                    const result = await response.json();
+                    if (!result.access_token || typeof result.access_token !== 'string' || typeof result.expires_in !== 'number' || !Number.isFinite(result.expires_in) || result.expires_in <= 0)
+                        throw new Error();
+                    token = result.access_token;
+                    expiresAt = Date.now() + result.expires_in * 1000;
+                    return token;
+                }
+                catch {
+                    throw new Error('Google access expired or was revoked. Reconnect your Google account.');
+                }
+                finally {
+                    pending = undefined;
+                }
+            })();
+        return pending;
+    };
+}

package/dist/googlesheets/parseConnectionString.js

@@ -36,6 +36,18 @@ function parseSheetsConnectionString(url) {
         result.privateKey = config.privatekey;
     if (config.accesstoken)
         result.accessToken = config.accesstoken;
+    if (config.refreshtoken)
+        result.refreshToken = config.refreshtoken;
+    if (config.oauthclientid)
+        result.oauthClientId = config.oauthclientid;
+    if (config.oauthclientsecret)
+        result.oauthClientSecret = config.oauthclientsecret;
+    if (config.tokenexpiresat) {
+        const expiry = Number(config.tokenexpiresat);
+        if (!Number.isFinite(expiry) || expiry < 0)
+            throw new Error('Invalid OAuth token expiry.');
+        result.tokenExpiresAt = expiry;
+    }
     if (config.apikey)
         result.apiKey = config.apikey;
     if (config.sheetmapping) {

package/dist/googlesheets/tableClient.js

@@ -6,11 +6,6 @@ const metadata_1 = require("../base/metadata");
 const helpers_1 = require("./helpers");
 const retry_1 = require("./retry");
 // ─── Utility ──────────────────────────────────────────────────────────────────
-function resolveIdField(fields) {
-    if (Object.prototype.hasOwnProperty.call(fields, 'id'))
-        return 'id';
-    return Object.keys(fields).find(name => name.endsWith('_id') || name.endsWith('Id') || name.toLowerCase() === 'id');
-}
 // ─── Table Client ─────────────────────────────────────────────────────────────
 class SheetsTableClient {
     constructor(adapter, modelName, sheetMapping) {
@@ -156,7 +151,7 @@ class SheetsTableClient {
         return rows.length;
     }
     assignId(data, fields) {
-        const idFieldName = resolveIdField(fields);
+        const idFieldName = (0, metadata_1.resolveIdField)(fields);
         if (!idFieldName)
             return;
         const fieldDef = fields[idFieldName];
@@ -201,23 +196,10 @@ class SheetsTableClient {
             }
             return this.rowToValues(data, headers);
         });
-        try {
-            await this.adapter.appendRange(`${this.escSheetName}!A:A`, batchValues);
-            return { count: batchValues.length };
-        }
-        catch (e) {
-            if (!args.skipDuplicates)
-                throw e;
-            let count = 0;
-            for (const row of args.data) {
-                try {
-                    await this.create({ data: row });
-                    count++;
-                }
-                catch { /* skip */ }
-            }
-            return { count };
-        }
+        // Sheets has no unique constraints. An append failure must propagate;
+        // retrying individual rows could duplicate a batch the service accepted.
+        await this.adapter.appendRange(`${this.escSheetName}!A:A`, batchValues);
+        return { count: batchValues.length };
     }
     async update(args) {
         const { headers, rows } = await this.readAllRows();

package/dist/sqlite/engine.js

@@ -15,7 +15,8 @@ class SqliteEngine {
             throw new Error('better-sqlite3 package is required for SQLite support. Run: npm install better-sqlite3');
         this.filePath = (adapterConfig.connectionString ?? '')
             .replace(/^sqlite:\/\/\//i, '/')
-            .replace(/^sqlite:\/\//i, '');
+            .replace(/^sqlite:\/\//i, '')
+            .replace(/^sqlite:/i, '');
     }
     getDb() {
         if (!this.db)

package/dotnet/Base/Core.cs

@@ -259,40 +259,30 @@ public enum Dialect
             {
                 var key = kv.Key;
                 var value = kv.Value;
-                if (key == "OR" && value is System.Collections.IList orList && orList.Count > 0)
+                if (key == "OR" || key == "AND" || key == "NOT")
                 {
+                    var items = value is System.Collections.IList list
+                        ? list : new object[] { value };
                     var subs = new List<string>();
                     var i = 0;
-                    foreach (var item in orList)
+                    foreach (var item in items)
                     {
                         if (item is Dictionary<string, object> subMap)
                         {
-                            var s = ParseWhere(subMap, parameters, dialect, $"{prefix}or{i++}_");
-                            if (!string.IsNullOrEmpty(s)) subs.Add(s);
+                            var s = ParseWhere(subMap, parameters, dialect, $"{prefix}{key}{i++}_");
+                            subs.Add(string.IsNullOrEmpty(s) ? "1=1" : s);
                         }
                     }
-                    if (subs.Count > 0) conditions.Add("(" + string.Join(" OR ", subs) + ")");
-                    continue;
-                }
-                if (key == "AND" && value is System.Collections.IList andList && andList.Count > 0)
-                {
-                    var subs = new List<string>();
-                    var i = 0;
-                    foreach (var item in andList)
+                    if (subs.Count == 0)
                     {
-                        if (item is Dictionary<string, object> subMap)
-                        {
-                            var s = ParseWhere(subMap, parameters, dialect, $"{prefix}and{i++}_");
-                            if (!string.IsNullOrEmpty(s)) subs.Add(s);
-                        }
+                        if (key == "OR") conditions.Add("1=0");
+                    }
+                    else
+                    {
+                        var joiner = key == "AND" ? " AND " : " OR ";
+                        var negation = key == "NOT" ? "NOT " : "";
+                        conditions.Add(negation + "(" + string.Join(joiner, subs) + ")");
                     }
-                    if (subs.Count > 0) conditions.Add("(" + string.Join(" AND ", subs) + ")");
-                    continue;
-                }
-                if (key == "NOT" && value is Dictionary<string, object> notMap)
-                {
-                    var s = ParseWhere(notMap, parameters, dialect, $"{prefix}not_");
-                    if (!string.IsNullOrEmpty(s)) conditions.Add("NOT (" + s + ")");
                     continue;
                 }
 

package/golang/base/where.go

@@ -80,55 +80,41 @@ func buildWhereRec(where map[string]interface{}, dialect Dialect, args *[]interf
 		value := where[key]
 
 		switch key {
-		case "OR":
-			if list, ok := toSlice(value); ok && len(list) > 0 {
-				var subs []string
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok && m != nil {
-						if s := buildWhereRec(m, dialect, args, ph, fmt.Sprintf("%sor%d_", prefix, i)); s != "" {
-							subs = append(subs, s)
-						}
-					}
-				}
-				if len(subs) > 0 {
-					conditions = append(conditions, "("+strings.Join(subs, " OR ")+")")
-				}
-				continue
-			}
-		case "AND":
-			if list, ok := toSlice(value); ok && len(list) > 0 {
-				var subs []string
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok && m != nil {
-						if s := buildWhereRec(m, dialect, args, ph, fmt.Sprintf("%sand%d_", prefix, i)); s != "" {
-							subs = append(subs, s)
-						}
-					}
-				}
-				if len(subs) > 0 {
-					conditions = append(conditions, "("+strings.Join(subs, " AND ")+")")
-				}
-				continue
-			}
-		case "NOT":
+		case "OR", "AND", "NOT":
 			items := value
 			if m, ok := value.(map[string]interface{}); ok {
 				items = []interface{}{m}
 			}
-			if list, ok := toSlice(items); ok && len(list) > 0 {
-				var subs []string
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok && m != nil {
-						if s := buildWhereRec(m, dialect, args, ph, fmt.Sprintf("%snot%d_", prefix, i)); s != "" {
-							subs = append(subs, s)
-						}
+			list, ok := toSlice(items)
+			if !ok {
+				continue
+			}
+			var subs []string
+			for i, item := range list {
+				if m, ok := item.(map[string]interface{}); ok {
+					s := buildWhereRec(cleanWhere(m), dialect, args, ph, fmt.Sprintf("%s%s%d_", prefix, key, i))
+					if s == "" {
+						s = "1=1"
 					}
+					subs = append(subs, s)
 				}
-				if len(subs) > 0 {
-					conditions = append(conditions, "NOT ("+strings.Join(subs, " AND ")+")")
+			}
+			if len(subs) == 0 {
+				if key == "OR" {
+					conditions = append(conditions, "1=0")
 				}
-				continue
+			} else {
+				joiner := " OR "
+				if key == "AND" {
+					joiner = " AND "
+				}
+				clause := "(" + strings.Join(subs, joiner) + ")"
+				if key == "NOT" {
+					clause = "NOT " + clause
+				}
+				conditions = append(conditions, clause)
 			}
+			continue
 		}
 
 		conditions = append(conditions, buildFieldCondition(key, value, dialect, args, ph, prefix)...)
@@ -171,13 +157,10 @@ func buildFieldCondition(key string, value interface{}, dialect Dialect, args *[
 		case "not":
 			if val == nil {
 				parts = append(parts, col+" IS NOT NULL")
-			} else if nested, ok := val.(map[string]interface{}); ok && !isOperatorMap(val) {
-				if nestedArgs := len(*args); true {
-					nestedCond := buildWhereRec(map[string]interface{}{key: nested}, dialect, args, ph, key+"_not_")
-					_ = nestedArgs
-					if nestedCond != "" {
-						parts = append(parts, "NOT ("+nestedCond+")")
-					}
+			} else if nested, ok := val.(map[string]interface{}); ok {
+				nestedCond := buildWhereRec(map[string]interface{}{key: nested}, dialect, args, ph, key+"_not_")
+				if nestedCond != "" {
+					parts = append(parts, "NOT ("+nestedCond+")")
 				}
 			} else {
 				parts = append(parts, fmt.Sprintf("%s <> %s", col, addArg(val)))
@@ -308,4 +291,4 @@ func BuildOrderBy(orderBy interface{}, dialect Dialect) string {
 		return ""
 	}
 	return "ORDER BY " + strings.Join(parts, ", ")
-}
+}

package/golang/base/where_test.go

@@ -0,0 +1,57 @@
+package base
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// SQLite is provided by Python's standard library to keep the adapter driver-neutral.
+func TestSharedQueryContract(t *testing.T) {
+	fixtures, err := os.ReadFile(filepath.Join("..", "..", "test", "fixtures", "query-semantics.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var contract struct {
+		Rows  []map[string]interface{} `json:"rows"`
+		Cases []struct {
+			Name  string                 `json:"name"`
+			Where map[string]interface{} `json:"where"`
+			IDs   []int                  `json:"ids"`
+		} `json:"cases"`
+	}
+	if err := json.Unmarshal(fixtures, &contract); err != nil {
+		t.Fatal(err)
+	}
+	python, err := exec.LookPath("python3")
+	if err != nil {
+		t.Fatal("python3 is required for the SQLite query contract")
+	}
+	for _, c := range contract.Cases {
+		t.Run(c.Name, func(t *testing.T) {
+			clause, args := BuildWhere(c.Where, DialectSqlite, func(int) string { return "?" })
+			payload, _ := json.Marshal(map[string]interface{}{"rows": contract.Rows, "clause": clause, "args": args})
+			cmd := exec.Command(python, "-c", `import json,sqlite3,sys
+p=json.loads(sys.argv[1])
+db=sqlite3.connect(':memory:')
+db.execute('CREATE TABLE users (id INTEGER, score INTEGER)')
+db.executemany('INSERT INTO users VALUES (?,?)',[(r['id'],r['score']) for r in p['rows']])
+sql='SELECT id FROM users'+(' WHERE '+p['clause'] if p['clause'] else '')+' ORDER BY id'
+print(json.dumps([r[0] for r in db.execute(sql,p['args'])]))`, string(payload))
+			output, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Fatalf("query failed: %v\n%s", err, output)
+			}
+			var got []int
+			if err := json.Unmarshal(output, &got); err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(got, c.IDs) {
+				t.Fatalf("got %v, want %v", got, c.IDs)
+			}
+		})
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@an5/adapters",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET, Go, Rust, and Google Sheets query execution.",
   "license": "MIT",
   "main": "dist/index.js",
@@ -58,16 +58,16 @@
     "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": "node test/unit.test.js && node test/package.test.js && node test/nbase.test.js && node --test test/version-sync.test.js && node --test test/query-semantics.test.js && node test/query-relations.integration.test.js && node --test test/sheets-oauth.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:integration:live": "node test/live-db.integration.test.js && node test/query-relations.integration.test.js",
+    "test:python": "node scripts/python-tests.js",
     "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",
+    "googleapis": "^183.0.0",
     "mssql": "^12.5.5",
     "pg": "^8.13.0"
   },
@@ -75,9 +75,22 @@
     "@types/mssql": "^9.1.8",
     "@types/node": "^20.11.0",
     "@types/pg": "^8.11.0",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "better-sqlite3": "^11.5.0"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "mysql2": "^3.0.0",
+    "better-sqlite3": "^11.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mysql2": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    }
   }
 }

package/python/base/sql.py

@@ -51,10 +51,8 @@ def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect:
 
     for key, value in clean_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)})")
+            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}or{i}_") or "1=1" for i, v in enumerate(value)]
+            conditions.append(f"({' OR '.join(sub)})" if sub else "1=0")
         elif key == "AND":
             items = value if isinstance(value, list) else [value]
             sub = [_parse_where(model_name, v, params, dialect, f"{prefix}and{i}_") for i, v in enumerate(items)]
@@ -63,10 +61,9 @@ def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect:
                 conditions.append(f"({' AND '.join(sub)})")
         elif key == "NOT":
             items = value if isinstance(value, list) else [value]
-            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}not{i}_") for i, v in enumerate(items)]
-            sub = [s for s in sub if s]
+            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}not{i}_") or "1=1" for i, v in enumerate(items)]
             if sub:
-                conditions.append(f"NOT ({' AND '.join(sub)})")
+                conditions.append(f"NOT ({' OR '.join(sub)})")
         else:
             col = _quote(key, dialect)
             pname = _sanitize_param_name(f"{prefix}{key}")
@@ -196,6 +193,8 @@ def _quote_table(t: str, dialect: str) -> str:
     # correct on MSSQL. Other dialects have to strip it and re-quote, or the
     # previous dialect's brackets follow the name into the new dialect.
     parts = _split_qualified(str(t))
+    if dialect == DIALECT_SQLITE and len(parts) == 2 and _strip_wrapping(_strip_wrapping(parts[0], "[", "]"), '"', '"').lower() == "dbo":
+        parts = parts[1:]
     if not parts:
         parts = [str(t)]
     return ".".join(_quote(p, dialect) for p in parts)

package/rust/src/adapter.rs

@@ -1238,6 +1238,7 @@ mod tests {
 
     #[tokio::test]
     async fn resolves_physical_table() {
+        let _guard = crate::base::metadata::TEST_METADATA_LOCK.lock().unwrap();
         crate::base::set_adapter_metadata(AdapterMetadata {
             model_to_table: HashMap::from([("User".to_string(), "[dbo].[Users]".to_string())]),
             ..Default::default()
@@ -1285,6 +1286,7 @@ mod tests {
 
     #[test]
     fn split_relations_uses_metadata() {
+        let _guard = crate::base::metadata::TEST_METADATA_LOCK.lock().unwrap();
         crate::base::set_adapter_metadata(AdapterMetadata {
             relation_map: HashMap::from([(
                 "Order".to_string(),

package/rust/src/base/dialect.rs

@@ -35,7 +35,11 @@ impl Dialect {
 
     /// Quote a single identifier (column or table part).
     pub fn quote_identifier(&self, name: &str) -> String {
-        let raw = strip_wrapping(strip_wrapping(name, "[", "]"), "\"", "\"");
+        let raw = if name.starts_with('[') && name.ends_with(']') {
+            strip_wrapping(name, "[", "]").replace("]]", "]")
+        } else if name.starts_with('"') && name.ends_with('"') {
+            strip_wrapping(name, "\"", "\"").replace("\"\"", "\"")
+        } else { name.to_string() };
         match self {
             Dialect::Postgres | Dialect::Sqlite => {
                 format!("\"{}\"", raw.replace('"', "\"\""))
@@ -46,15 +50,31 @@ impl Dialect {
 
     /// Quote a possibly schema-qualified table name (`dbo.users`).
     pub fn quote_table(&self, table: &str) -> String {
-        let t = table.trim();
-        // Already quoted by the generator: `[dbo].[User]`.
-        if t.starts_with('[') || t.starts_with('"') {
-            return t.to_string();
+        let mut parts = Vec::new();
+        let mut part = String::new();
+        let mut closing = None;
+        let mut chars = table.trim().chars().peekable();
+        while let Some(ch) = chars.next() {
+            if let Some(close) = closing {
+                part.push(ch);
+                if ch == close {
+                    if chars.peek() == Some(&close) {
+                        part.push(chars.next().unwrap());
+                    } else { closing = None; }
+                }
+            } else if ch == '[' || ch == '"' {
+                closing = Some(if ch == '[' { ']' } else { '"' });
+                part.push(ch);
+            } else if ch == '.' {
+                parts.push(std::mem::take(&mut part));
+            } else { part.push(ch); }
         }
-        t.split('.')
-            .map(|p| self.quote_identifier(p))
-            .collect::<Vec<_>>()
-            .join(".")
+        parts.push(part);
+        if *self == Dialect::Sqlite && parts.len() == 2 {
+            let schema = strip_wrapping(strip_wrapping(parts[0].trim(), "[", "]"), "\"", "\"");
+            if schema.eq_ignore_ascii_case("dbo") { parts.remove(0); }
+        }
+        parts.iter().map(|p| self.quote_identifier(p.trim())).collect::<Vec<_>>().join(".")
     }
 
     /// Positional placeholder: `$N` for Postgres, `?` otherwise.
@@ -133,6 +153,15 @@ pub fn vector_distance(a: &[f64], b: &[f64], metric: &str) -> f64 {
 mod tests {
     use super::*;
 
+    #[test]
+    fn converts_generated_table_names_for_sqlite() {
+        assert_eq!(Dialect::Sqlite.quote_table("[dbo].[users]"), "\"users\"");
+        assert_eq!(Dialect::Sqlite.quote_table("[main].[users]"), "\"main\".\"users\"");
+        assert_eq!(Dialect::Sqlite.quote_table("[dot.name]"), "\"dot.name\"");
+        assert_eq!(Dialect::Postgres.quote_table("[dbo].[a]]b]"), "\"dbo\".\"a]b\"");
+        assert_eq!(Dialect::Mssql.quote_table("[dbo].[a]]b]"), "[dbo].[a]]b]");
+    }
+
     #[test]
     fn detects_dialects() {
         assert_eq!(

package/rust/src/base/metadata.rs

@@ -2,6 +2,9 @@
 //!
 //! Mirrors the Go `an5adapters/base` metadata store.
 
+#[cfg(test)]
+pub(crate) static TEST_METADATA_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
 use std::collections::HashMap;
 use std::sync::{OnceLock, RwLock};
 
@@ -123,6 +126,7 @@ mod tests {
     fn resolves_table_with_case_fallback() {
         let mut map = HashMap::new();
         map.insert("User".to_string(), "[dbo].[Users]".to_string());
+        let _guard = TEST_METADATA_LOCK.lock().unwrap();
         set_adapter_metadata(AdapterMetadata {
             model_to_table: map,
             ..Default::default()

package/rust/src/base/where_builder.rs

@@ -44,10 +44,6 @@ fn as_object(v: &Value) -> Option<&Map<String, Value>> {
     }
 }
 
-fn is_list(v: &Value) -> bool {
-    v.is_array()
-}
-
 fn to_list(v: &Value) -> Vec<Value> {
     match v {
         Value::Array(items) => items.clone(),
@@ -113,38 +109,23 @@ fn build_where_rec(
         let value = &where_obj[key];
 
         match key.as_str() {
-            "AND" | "OR" if is_list(value) => {
-                let joiner = if key == "AND" { " AND " } else { " OR " };
+            "AND" | "OR" | "NOT" => {
                 let mut subs: Vec<String> = Vec::new();
                 for item in to_list(value) {
                     if let Some(m) = as_object(&item) {
-                        let s = build_where_rec(m, dialect, args, ph);
-                        if !s.is_empty() {
-                            subs.push(s);
-                        }
+                        let s = build_where_rec(&clean_where(m), dialect, args, ph);
+                        subs.push(if s.is_empty() { "1=1".to_string() } else { s });
                     }
                 }
-                if !subs.is_empty() {
-                    conditions.push(format!("({})", subs.join(joiner)));
-                }
-                continue;
-            }
-            "NOT" => {
-                let mut subs: Vec<String> = Vec::new();
-                for item in to_list(value) {
-                    if let Some(m) = as_object(&item) {
-                        let s = build_where_rec(m, dialect, args, ph);
-                        if !s.is_empty() {
-                            subs.push(s);
-                        }
-                    }
-                }
-                if !subs.is_empty() {
-                    conditions.push(format!("NOT ({})", subs.join(" AND ")));
+                if subs.is_empty() {
+                    if key == "OR" { conditions.push("1=0".to_string()); }
+                } else {
+                    let joiner = if key == "AND" { " AND " } else { " OR " };
+                    let negation = if key == "NOT" { "NOT " } else { "" };
+                    conditions.push(format!("{}({})", negation, subs.join(joiner)));
                 }
                 continue;
             }
-            "AND" | "OR" => continue,
             _ => {}
         }