queryapigate 0.34.2__tar.gz → 0.35.0__tar.gz

{queryapigate-0.34.2/queryapigate.egg-info → queryapigate-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queryapigate
-Version: 0.34.2
+Version: 0.35.0
 Summary: Turn SQL into governed REST APIs over MySQL, PostgreSQL, ClickHouse, SQLite, DuckDB, H2, MongoDB, and Parquet/CSV/JSON files - JSON, CSV, Parquet or Excel out, with scoped keys, an admin Console and MCP for AI agents.
 Author-email: Anantha Raju C <arcswdev@gmail.com>
 License-Expression: FSL-1.1-MIT

{queryapigate-0.34.2 → queryapigate-0.35.0}/queryapigate/__init__.py

@@ -1,5 +1,5 @@
 """QueryAPIGate - expose SQL databases as a REST API."""
-__version__ = "0.34.2"
+__version__ = "0.35.0"
 
 from .app import create_app  # noqa: E402  (app imports __version__)
 

{queryapigate-0.34.2 → queryapigate-0.35.0}/queryapigate/databases.py

@@ -15,8 +15,8 @@ NAMES = {'postgres': 'PostgreSQL', 'mysql': 'MySQL', 'sqlite': 'SQLite', 'duckdb
 TIER_1 = tuple(t for t in TYPES if t not in experimental.DB_TYPES)
 
 # Run against a real server (or, for SQLite, a real file) on every CI push: tests/test_integration.py's classes, and
-# the main suite for SQLite. MongoDB has no such test yet - the main reason it is experimental.
-INTEGRATION_TESTED = frozenset({'postgres', 'mysql', 'clickhouse', 'duckdb', 'h2', 'jdbc', 'sqlite'})
+# the main suite for SQLite. CI fails if one skips.
+INTEGRATION_TESTED = frozenset({'postgres', 'mysql', 'clickhouse', 'duckdb', 'h2', 'jdbc', 'sqlite', 'mongo'})
 
 # Where the database itself refuses writes in a read-only session, beside QueryAPIGate's own SQL check (sqltools):
 # MySQL and PostgreSQL read-only transactions, ClickHouse readonly=1, SQLite mode=ro. DuckDB, H2 and JDBC rest on

{queryapigate-0.34.2 → queryapigate-0.35.0}/queryapigate/quotas.py

@@ -109,6 +109,10 @@ class _Counter:
 
 
 _counter = _Counter()
+# Held from taking the unwritten counts to storing them, and by forget(): a forget that ran while a write was in flight
+# found the counts in neither place - taken from _counter, not yet in the store - and the write then stored them after
+# the person was forgotten (CI, 2026-10-14). Reentrant: forget() writes first, under it.
+_writing = threading.RLock()
 
 
 class _Shared:
@@ -209,20 +213,21 @@ def _stored(caller, key):
 def write():
     """Add what's been counted to the store(s) it was counted against - the history writer's batch calls this (and
     tests). A failed write puts the counts back, to be written next time rather than lost."""
-    taken = _counter.take()
-    if not taken:
-        return
-    by_target = {}
-    for (target, caller, key), counts in taken.items():
-        by_target.setdefault(target, {})[(caller, key)] = counts
-    stamp = datetime.now().strftime(_TIME)
-    try:
-        for target, counted in by_target.items():
-            _write(target, counted, stamp)
-    except Exception:
-        _counter.put_back(taken)
-        raise
-    _counter.forget_reads()
+    with _writing:
+        taken = _counter.take()
+        if not taken:
+            return
+        by_target = {}
+        for (target, caller, key), counts in taken.items():
+            by_target.setdefault(target, {})[(caller, key)] = counts
+        stamp = datetime.now().strftime(_TIME)
+        try:
+            for target, counted in by_target.items():
+                _write(target, counted, stamp)
+        except Exception:
+            _counter.put_back(taken)
+            raise
+        _counter.forget_reads()
 
 
 def _write(target, counted, stamp):
@@ -249,13 +254,15 @@ def _ensure_written():
 def forget(caller):
     """Delete a caller's usage counts - unwritten, stored and in Redis (ADR 0016: forgetting a person). Their quota's
     count for the period starts again. Returns how many periods there were: what this process hadn't written yet is
-    written first, so the answer doesn't depend on whether a background write happened to come first."""
-    write()
-    with _counter.lock:
-        for slot in [s for s in _counter.read if s[0] == caller]:
-            del _counter.read[slot]
-    with db.transaction() as tx:
-        stored = tx.execute('DELETE FROM usage_counters WHERE caller = ?', (caller,)).rowcount
+    written first, so the answer doesn't depend on whether a background write happened to come first - or was in
+    flight: that one is waited for (_writing)."""
+    with _writing:
+        write()
+        with _counter.lock:
+            for slot in [s for s in _counter.read if s[0] == caller]:
+                del _counter.read[slot]
+        with db.transaction() as tx:
+            stored = tx.execute('DELETE FROM usage_counters WHERE caller = ?', (caller,)).rowcount
     shared = _redis()
     if shared is not None:
         try:

{queryapigate-0.34.2 → queryapigate-0.35.0/queryapigate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queryapigate
-Version: 0.34.2
+Version: 0.35.0
 Summary: Turn SQL into governed REST APIs over MySQL, PostgreSQL, ClickHouse, SQLite, DuckDB, H2, MongoDB, and Parquet/CSV/JSON files - JSON, CSV, Parquet or Excel out, with scoped keys, an admin Console and MCP for AI agents.
 Author-email: Anantha Raju C <arcswdev@gmail.com>
 License-Expression: FSL-1.1-MIT

{queryapigate-0.34.2 → queryapigate-0.35.0}/tests/test_data_protection.py

@@ -147,6 +147,27 @@ class ForgetTests(unittest.TestCase):
         quotas.write()  # what was still unwritten was forgotten too
         self.assertEqual(self.periods(self.PERSON), 0)
 
+    def test_a_write_in_flight_is_waited_for_not_missed(self):
+        # CI, 2026-10-14: the background writer had taken the unwritten month's count and was writing it when forget
+        # ran - forget found it in neither place, deleted the rest, and the writer then stored it after the person
+        # was forgotten. Forgetting now waits for a write in flight, and deletes what it wrote.
+        import threading
+        writing, release, original = threading.Event(), threading.Event(), quotas._write
+
+        def slow_write(target, counted, stamp):
+            writing.set()
+            release.wait(5)
+            original(target, counted, stamp)
+        with mock.patch.object(quotas, '_write', slow_write):
+            writer = threading.Thread(target=quotas.write)
+            writer.start()
+            self.assertTrue(writing.wait(5))
+            threading.Timer(0.3, release.set).start()
+            forgotten = history.forget(self.PERSON, 'owner')
+            writer.join(5)
+        self.assertEqual(forgotten['usage_periods'], 2)
+        self.assertEqual(self.periods(self.PERSON), 0)
+
     def test_the_record_of_it_keeps_nothing_of_who(self):
         history.forget(self.PERSON, 'owner')
         entry = self.audit()[-1]

{queryapigate-0.34.2 → queryapigate-0.35.0}/tests/test_dependency_floors.py

@@ -11,10 +11,11 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 # Each package whose floor CI tests, and the extra that declares it - None for a core dependency. Every core
 # dependency is here, and every extra a stable feature needs (ADR 0017); the experimental features' extras (otel,
-# aws, mongo, h2) join when they graduate.
+# aws, h2) join when they graduate - mongo's already has, tested against a real server.
 FLOORS = {'Flask': None, 'Werkzeug': None, 'PyYAML': None, 'openpyxl': None,
           'duckdb': 'duckdb', 'sqlglot': 'flow', 'mcp': 'mcp', 'PyJWT': 'jwt', 'redis': 'redis',
-          'psycopg2-binary': 'postgres'}  # the PostgreSQL store, and live events' notifications (ADR 0021)
+          'psycopg2-binary': 'postgres',  # the PostgreSQL store, and live events' notifications (ADR 0021)
+          'pymongo': 'mongo'}
 
 
 def _project():

{queryapigate-0.34.2 → queryapigate-0.35.0}/tests/test_integration.py

@@ -478,5 +478,97 @@ class DuckDBTests(IntegrationBase, unittest.TestCase):
         self.assertEqual(len(self.query('SELECT * FROM queryapigate_it', '?page_size=100').get_json()), 7)
 
 
+class MongoTests(unittest.TestCase):
+    """MongoDB against a real server (QUERYAPIGATE_IT_MONGO): find() through /execute_mongo and saved queries, the
+    time limit, allowed_tables as collections, and the refusals that keep a find() a find() - each sent to the real
+    server's parser, not a mock's. Not IntegrationBase: there is no SQL to run."""
+    db, env_var = 'mongo', 'QUERYAPIGATE_IT_MONGO'
+
+    @classmethod
+    def setUpClass(cls):
+        raw = os.environ.get(cls.env_var)
+        if not raw:
+            raise unittest.SkipTest(f'{cls.env_var} not set')
+        cls.details = {**json.loads(raw), 'db': cls.db, 'active': True}
+
+    def setUp(self):
+        import pymongo
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        patcher = mock.patch.dict(os.environ, {'QUERYAPIGATE_HOME': self.tmp.name, 'QUERYAPIGATE_API_KEY': 'admin'})
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        write_connections({'it': self.details})
+        self.client = create_app().test_client()
+        self.admin = {'X-API-Key': 'admin'}
+        server = pymongo.MongoClient(self.details['host'], int(self.details.get('port') or 27017))
+        self.addCleanup(server.close)
+        self.mongo = server[self.details['database']]
+        for name in ('queryapigate_it', 'queryapigate_it_secret', 'queryapigate_it_slow'):
+            self.mongo.drop_collection(name)
+            self.addCleanup(self.mongo.drop_collection, name)
+        self.mongo.queryapigate_it.insert_many([{'id': i, 'name': f'Item {i}', 'price': i + 0.5} for i in range(1, 8)])
+        self.mongo.queryapigate_it_secret.insert_one({'token': 'tok_live_123'})
+
+    def find(self, headers=None, query='', **body):
+        return self.client.post(f'/execute_mongo{query}', headers=headers or self.admin,
+                                json={'connection_name': 'it', 'collection': 'queryapigate_it', **body})
+
+    def key(self, **grants):
+        res = self.client.post('/api/v1/api-keys', headers=self.admin, json={'name': 'partner', **grants})
+        self.assertEqual(res.status_code, 201, res.get_data(as_text=True))
+        return {'X-API-Key': res.get_json()['secret']}
+
+    def test_a_find_filters_projects_sorts_and_pages(self):
+        res = self.find(query='?page_size=2', filter={'price': {'$gte': 3}}, projection={'_id': 0, 'id': 1},
+                        sort={'id': -1})
+        self.assertEqual(res.status_code, 200, res.get_data(as_text=True))
+        self.assertEqual(res.get_json(), [{'id': 7}, {'id': 6}])
+        self.assertEqual(res.headers['X-Has-More'], 'true')
+
+    def test_a_saved_query_binds_a_typed_parameter(self):
+        self.assertEqual(save_query(self.client, headers=self.admin, body={
+            'filename': 'by_id', 'author': 'a', 'description': 'd', 'query_type': 'mongo',
+            'mongo_collection': 'queryapigate_it', 'mongo_filter': {'id': ':id'},
+            'mongo_projection': {'_id': 0, 'name': 1}, 'query_parameters': {'id': 'int'},
+            'connection_name': 'it'}).status_code, 201)
+        res = self.client.get('/q/by_id?id=3', headers=self.admin)
+        self.assertEqual((res.status_code, res.get_json()), (200, [{'name': 'Item 3'}]))
+
+    def test_the_time_limit_cancels_a_find(self):
+        self.mongo.queryapigate_it_slow.insert_many([{'s': 'x' * 40 + str(i)} for i in range(100_000)])
+        res = self.find(collection='queryapigate_it_slow', filter={'s': {'$regex': 'y$'}}, timeout=0.001)
+        self.assertEqual((res.status_code, res.get_json()['code']), (504, 'query_timeout'))
+        unlimited = self.find(collection='queryapigate_it_slow', filter={'s': {'$regex': 'y$'}})
+        self.assertEqual(unlimited.status_code, 200)  # the same find, given its time, simply finds nothing
+
+    def test_allowed_tables_are_the_collections_a_key_may_read(self):
+        partner = self.key(connections=['it'], allowed_tables=['queryapigate_it'])
+        self.assertEqual(self.find(partner).status_code, 200)
+        refused = self.find(partner, collection='queryapigate_it_secret')
+        self.assertEqual((refused.status_code, refused.get_json()['code']), (403, 'table_not_allowed'))
+        self.assertNotIn('tok_live', refused.get_data(as_text=True))
+
+    def test_server_side_javascript_and_injected_operators_never_reach_the_server(self):
+        js = {'$function': {'body': 'function() { return true; }', 'args': [], 'lang': 'js'}}
+        for body in ({'filter': {'$where': 'true'}}, {'filter': {'$expr': js}}, {'projection': {'x': js}},
+                     {'sort': {'x': js}}):
+            with self.subTest(body=body):
+                res = self.find(**body)
+                self.assertEqual((res.status_code, res.get_json()['code']), (403, 'mongo_operator_forbidden'))
+        injected = self.find(filter={'name': ':u'}, params={'u': {'$ne': None}})
+        self.assertEqual((injected.status_code, injected.get_json()['code']), (400, 'param_invalid'))
+
+    def test_the_schema_lists_collections_and_the_server_its_databases(self):
+        res = self.client.get('/connections/it/schema', headers=self.admin)
+        self.assertEqual(res.status_code, 200, res.get_data(as_text=True))
+        self.assertIn('queryapigate_it', {t['name'] for t in res.get_json()['tables']})
+        listed = self.client.post('/api/v1/connections/databases', headers=self.admin, json=self.details)
+        self.assertEqual(listed.status_code, 200, listed.get_data(as_text=True))
+        self.assertIn(self.details['database'], json.dumps(listed.get_json()))
+        tested = self.client.post('/api/v1/connections/test', headers=self.admin, json=self.details)
+        self.assertEqual(tested.status_code, 200, tested.get_data(as_text=True))
+
+
 if __name__ == '__main__':
     unittest.main()