File size: 4,426 Bytes
8628c98
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
04b6a97
8628c98
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
"""
ALLI Backend - MongoDB Connection Manager
Handles resilient MongoDB Atlas connection lifecycle, lazy connect, and collection/index setup.
"""

import os
from datetime import datetime, timezone
from typing import Optional, Any
import env

try:
    from pymongo import MongoClient
    from pymongo.errors import ConnectionFailure, PyMongoError
    PYMONGO_AVAILABLE = True
except ImportError:
    MongoClient = None
    ConnectionFailure = Exception
    PyMongoError = Exception
    PYMONGO_AVAILABLE = False


def get_utc_now() -> str:
    """Return current UTC timestamp in ISO-8601 format."""
    return datetime.now(timezone.utc).isoformat()


class MongoConnectionMixin:
    """Mixin managing MongoDB Atlas client, lazy connectivity, and indexes."""

    def _init_connection(self, uri: Optional[str] = None, db_name: Optional[str] = None) -> None:
        self.uri = uri or os.environ.get("MONGODB_URI") or env.MONGODB_URI
        self.db_name = db_name or os.environ.get("MONGODB_DB_NAME") or env.MONGODB_DB_NAME
        self.client: Optional[Any] = None
        self.collection: Optional[Any] = None
        self.users_collection: Optional[Any] = None
        self._connected_attempted = False
        self._is_connected = False

    @property
    def is_connected(self) -> bool:
        if not self._connected_attempted:
            self._ensure_connected()
        return self._is_connected

    @is_connected.setter
    def is_connected(self, val: bool) -> None:
        self._connected_attempted = True
        self._is_connected = bool(val)

    def _ensure_connected(self) -> bool:
        if self._connected_attempted:
            return self._is_connected
        self._connected_attempted = True
        if PYMONGO_AVAILABLE and self.uri and MongoClient is not None:
            try:
                # Fast timeout (1500ms) so requests never block serverless invocations
                self.client = MongoClient(
                    self.uri,
                    serverSelectionTimeoutMS=1500,
                    connectTimeoutMS=1500,
                )
                self.client.admin.command("ping")
                db = self.client[self.db_name]
                self.collection = db["workflows"]
                self.users_collection = db["users"]
                self._ensure_indexes(db)
                self._is_connected = True
                print(
                    f"[ALLI MongoDB] Successfully connected to database '{self.db_name}' "
                    "(workflows, users, orgs & catalogs collections)"
                )
            except Exception as e:
                print(
                    f"[ALLI MongoDB] Connection skipped or unavailable ({str(e)}). "
                    "Using resilient in-memory storage."
                )
                self._is_connected = False
        else:
            self._is_connected = False
        return self._is_connected

    def _ensure_indexes(self, db: Any) -> None:
        """Create non-blocking background indexes across core collections."""
        index_specs = [
            ("users", "user_id", {"unique": True}),
            ("workflows", "id", {}),
            ("workflows", "user_id", {}),
            ("workflows", "org_id", {}),
            ("organizations", "org_id", {"unique": True}),
            ("organizations", "slug", {}),
            ("org_memberships", [("org_id", 1), ("user_id", 1)], {"unique": True}),
            ("org_memberships", "user_id", {}),
            ("audit_logs", [("org_id", 1), ("timestamp", -1)], {}),
            ("blueprints", "package", {}),
            ("node_schemas", "type", {}),
            ("staged_node_schemas", "node_type", {}),
            ("templates", "id", {}),
            ("plans", "id", {}),
            ("learning_modules", "id", {}),
            ("blog_posts", "slug", {}),
            ("admin_emails", "email", {"unique": True}),
            ("workspace_env_vars", [("org_id", 1), ("key", 1)], {"unique": True}),
        ]
        for col_name, keys, opts in index_specs:
            try:
                db[col_name].create_index(keys, background=True, **opts)
            except Exception:
                pass

    def get_collection(self, name: str) -> Optional[Any]:
        """Return PyMongo collection handle when connected, else None."""
        if not self.is_connected or self.client is None:
            return None
        return self.client[self.db_name][name]