[LOCAL-DB]: Initial Implementation

.github/workflows/test-cloud.yml

@@ -18,7 +18,6 @@ jobs:
         working-directory: jac-cloud
     env:
         SHOW_ENDPOINT_RETURNS: true
-        REDIS_HOST: redis://localhost
     services:
       redis:
         image: redis
@@ -52,13 +51,11 @@ jobs:
         pip install -e .
         pip install pytest
 
-    - name: Run tests
-      run: |
-        jac clean && jac tool gen_parser
-        jac serve jac_cloud/tests/simple_graph_mini.jac --port 8001 &
-        sleep 3 && pytest -s jac_cloud/tests/test_simple_graph_mini.py
-
-        export DATABASE_HOST="mongodb://localhost/?retryWrites=true&w=majority"
-        jac clean && jac tool gen_parser
-        jac serve jac_cloud/tests/simple_graph.jac --port 8000 &
-        sleep 3 && pytest -s jac_cloud/tests/test_simple_graph.py
+    - name: Run tests without mongodb and redis
+      run: pytest -sx
+    - name: Run tests with mongodb and redis
+      run: pytest -sx
+      env:
+        SHOW_ENDPOINT_RETURNS: true
+        DATABASE_HOST: mongodb://localhost/?retryWrites=true&w=majority
+        REDIS_HOST: redis://localhost

jac-cloud/jac_cloud/jaseci/datasources/__init__.py

@@ -1,11 +1,13 @@
 """Jaseci Datasources."""
 
 from .collection import Collection
+from .localdb import MontyClient
 from .redis import CodeRedis, Redis, TokenRedis
 
 
 __all__ = [
     "Collection",
+    "MontyClient",
     "CodeRedis",
     "Redis",
     "TokenRedis",

jac-cloud/jac_cloud/jaseci/datasources/collection.py

@@ -46,6 +46,9 @@
 )
 from pymongo.server_api import ServerApi
 
+from .localdb import MontyClient, set_storage
+from ..utils import logger
+
 T = TypeVar("T")
 
 
@@ -137,16 +140,23 @@ def __documents__(cls, docs: Cursor) -> Generator[T, None, None]:
     @staticmethod
     def get_client() -> MongoClient:
         """Return pymongo.database.Database for mongodb connection."""
-        if not isinstance(Collection.__client__, MongoClient):
-            Collection.__client__ = MongoClient(
-                getenv(
-                    "DATABASE_HOST",
-                    "mongodb://localhost/?retryWrites=true&w=majority",
-                ),
-                server_api=ServerApi("1"),
-            )
-
-        return Collection.__client__
+        if (client := Collection.__client__) is None:
+            if host := getenv("DATABASE_HOST"):
+                client = Collection.__client__ = MongoClient(
+                    host,
+                    server_api=ServerApi("1"),
+                )
+            else:
+                logger.info("DATABASE_HOST is not available! Using LocalDB...")
+                set_storage(
+                    repository="mydatabase",
+                    storage="sqlite",
+                    mongo_version="4.4",
+                    use_bson=True,
+                )
+                client = Collection.__client__ = MontyClient("mydatabase")
+
+        return client
 
     @staticmethod
     def get_session() -> ClientSession:

jac-cloud/jac_cloud/jaseci/datasources/localdb.py

@@ -0,0 +1,163 @@
+"""Monty Implementations."""
+
+from typing import Any
+
+from montydb import MontyClient as _MontyClient, set_storage  # type: ignore[import-untyped]
+from montydb.collection import MontyCollection as _MontyCollection  # type: ignore[import-untyped]
+from montydb.database import MontyDatabase as _MontyDatabase  # type: ignore[import-untyped]
+
+from pymongo import DeleteMany, DeleteOne, InsertOne, UpdateMany, UpdateOne
+from pymongo.cursor import Cursor
+from pymongo.results import BulkWriteResult, InsertManyResult, InsertOneResult
+
+
+class MontyClientSession:
+    """Monty Client Session."""
+
+    def start_transaction(self) -> "MontyClientSession":
+        """Start transaction."""
+        return self
+
+    def abort_transaction(self) -> None:
+        """Abort transaction."""
+
+    def commit_transaction(self) -> None:
+        """Commit transaction."""
+
+    def __enter__(self) -> "MontyClientSession":
+        """Enter execution."""
+        return self
+
+    def __exit__(
+        self, exc_type: Any, exc_val: Any, exc_tb: Any  # noqa: ANN401
+    ) -> None:
+        """Exit execution."""
+        pass
+
+
+class MontyCollection(_MontyCollection):
+    """Monty Collection."""
+
+    def __init__(self, col: _MontyCollection) -> None:
+        """Override Init."""
+        self.__dict__.update(col.__dict__)
+
+    def create_indexes(self, *args, **kwargs: Any) -> None:  # noqa: ANN401, ANN002
+        """Bypass Create Indexes."""
+        pass
+
+    def insert_one(
+        self, document: dict, session: MontyClientSession | None = None
+    ) -> InsertOneResult:
+        """Override insert_one."""
+        return super().insert_one(document)
+
+    def insert_many(
+        self,
+        documents: list[dict],
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> InsertManyResult:
+        """Override insert_many."""
+        return super().insert_many(documents, **kwargs)
+
+    def find(
+        self,
+        filter: dict | None = None,
+        projection: dict | None = None,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Cursor:
+        """Override find."""
+        return super().find(filter, **kwargs)
+
+    def find_one(
+        self,
+        filter: dict | None = None,
+        projection: dict | None = None,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> Any | None:
+        """Override find_one."""
+        return super().find_one(filter, **kwargs)
+
+    def count_documents(
+        self,
+        filter: dict,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> int:
+        """Override count_documents."""
+        return super().count_documents(filter, **kwargs)
+
+    def bulk_write(
+        self,
+        ops: list[InsertOne | DeleteMany | DeleteOne | UpdateMany | UpdateOne],
+        ordered: bool = True,
+        session: MontyClientSession | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> BulkWriteResult:
+        """Bulk write operations."""
+        deleted_count = 0
+        inserted_count = 0
+        modified_count = 0
+
+        for op in ops:
+            match op:
+                case InsertOne():
+                    if self.insert_one(op._doc).inserted_id:
+                        inserted_count += 1
+                case DeleteMany():
+                    deleted_count += self.delete_many(op._filter).deleted_count
+                case DeleteOne():
+                    deleted_count += self.delete_one(op._filter).deleted_count
+                case UpdateMany():
+                    modified_count += self.update_many(
+                        op._filter, op._doc
+                    ).modified_count
+                case UpdateOne():
+                    modified_count += self.update_one(
+                        op._filter, op._doc
+                    ).modified_count
+                case _:
+                    pass
+
+        return BulkWriteResult(
+            {
+                "bulk_api_result": {},
+                "deleted_count": deleted_count,
+                "inserted_count": inserted_count,
+                "matched_count": deleted_count + modified_count,
+                "modified_count": modified_count,
+                "upserted_count": 0,
+                "upserted_ids": {},
+            },
+            True,
+        )
+
+
+class MontyDatabase(_MontyDatabase):
+    """Monty Database."""
+
+    def __init__(self, db: _MontyDatabase) -> None:
+        """Override Init."""
+        self.__dict__.update(db.__dict__)
+
+    def get_collection(self, name: str) -> MontyCollection:
+        """Get Collection."""
+        return MontyCollection(super().get_collection(name))  # noqa: B009
+
+
+class MontyClient(_MontyClient):
+    """Monty Client."""
+
+    def get_database(self, name: str) -> MontyDatabase:
+        """Get local database."""
+        return MontyDatabase(super().get_database(name))
+
+    def start_session(self) -> MontyClientSession:
+        """Start session."""
+        return MontyClientSession()
+
+
+__all__ = ["MontyClient", "set_storage"]

jac-cloud/jac_cloud/jaseci/datasources/redis.py

@@ -46,6 +46,7 @@ def get_rd() -> _Redis:
                     password=getenv("REDIS_PASS"),
                 )
             else:
+                logger.info("REDIS_HOST is not available! Using FakeRedis...")
                 Redis.__redis__ = FakeRedis()
 
         return Redis.__redis__

jac-cloud/jac_cloud/plugin/cli.py

@@ -13,7 +13,6 @@
 
 from pymongo.errors import ConnectionFailure, OperationFailure
 
-from .mini.cli_mini import serve_mini
 from ..core.architype import BulkWrite, NodeAnchor
 from ..core.context import SUPER_ROOT_ID
 from ..jaseci.datasources import Collection
@@ -31,10 +30,6 @@ def create_cmd() -> None:
 
         @cmd_registry.register
         def serve(filename: str, host: str = "0.0.0.0", port: int = 8000) -> None:
-            if not getenv("DATABASE_HOST"):
-                serve_mini(filename=filename, host=host, port=port)
-                return
-
             from jac_cloud import FastAPI
 
             """Serve the jac application."""