PyPI - datajunction-server - Versions diffs - 0.0.1a91__tar.gz → 0.0.1a91.dev0__tar.gz - Mend

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: datajunction-server
-Version: 0.0.1a91
+Version: 0.0.1a91.dev0
 Summary: DataJunction server library for running to a DataJunction server
 Project-URL: Homepage, https://datajunction.io
 Project-URL: Repository, https://github.com/DataJunction/dj

@@ -0,0 +1,5 @@
+"""
+Version for Hatch
+"""
+__version__ = "0.0.1a91.dev0"

@@ -0,0 +1,38 @@
+"""
+Add index on display name
+Revision ID: ae9eba981a2d
+Revises: c3d5f327296c
+Create Date: 2025-03-14 15:13:06.383265+00:00
+"""
+# pylint: disable=no-member, invalid-name, missing-function-docstring, unused-import, no-name-in-module
+from alembic import op
+# revision identifiers, used by Alembic.
+revision = "ae9eba981a2d"
+down_revision = "c3d5f327296c"
+branch_labels = None
+depends_on = None
+def upgrade():
+    op.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")
+    with op.batch_alter_table("noderevision", schema=None) as batch_op:
+        batch_op.create_index(
+            "ix_noderevision_display_name",
+            ["display_name"],
+            unique=False,
+            postgresql_using="gin",
+            postgresql_ops={"display_name": "gin_trgm_ops"},
+        )
+def downgrade():
+    with op.batch_alter_table("noderevision", schema=None) as batch_op:
+        batch_op.drop_index(
+            "ix_noderevision_display_name",
+            postgresql_using="gin",
+            postgresql_ops={"display_name": "gin_trgm_ops"},
+        )
+    op.execute("DROP EXTENSION IF EXISTS pg_trgm;")

@@ -14,6 +14,7 @@ from datajunction_server.database.notification_preference import NotificationPre
 from datajunction_server.database.user import User
 from datajunction_server.errors import DJDoesNotExistException
 from datajunction_server.internal.access.authentication.http import SecureAPIRouter
+from datajunction_server.internal.notifications import get_notification_preferences
 from datajunction_server.utils import get_and_update_current_user, get_session
 router = SecureAPIRouter(tags=["notifications"])
@@ -95,22 +96,20 @@ async def unsubscribe(
 @router.get("/notifications/")
-async def get_notification_preferences(
+async def get_user_notification_preferences(
     entity_name: Optional[str] = None,
     entity_type: Optional[EntityType] = None,
     session: AsyncSession = Depends(get_session),
     current_user: User = Depends(get_and_update_current_user),
 ) -> JSONResponse:
     """Subscribes to notificaitons by upserting a notification preference"""
-    statement = select(NotificationPreference).where(
-        NotificationPreference.user == current_user,
+    notification_preferences = await get_notification_preferences(
+        session=session,
+        user=current_user,
+        entity_name=entity_name,
+        entity_type=entity_type,
     )
-    if entity_name:
-        statement = statement.where(NotificationPreference.entity_name == entity_name)
-    if entity_type:
-        statement = statement.where(NotificationPreference.entity_type == entity_type)
-    result = await session.execute(statement)
-    notification_preferences = [
+    response = [
         {
             "entity_type": pref.entity_type,
             "entity_name": pref.entity_name,
@@ -119,6 +118,6 @@ async def get_notification_preferences(
             "username": pref.user.username,
             "alert_types": pref.alert_types,
         }
-        for pref in result.scalars().all()
+        for pref in notification_preferences
     ]
-    return JSONResponse(content=notification_preferences)
+    return JSONResponse(content=response)

@@ -27,7 +27,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import Mapped, joinedload, mapped_column, relationship, selectinload
 from sqlalchemy.sql.base import ExecutableOption
-from sqlalchemy.sql.operators import is_
+from sqlalchemy.sql.operators import is_, or_
 from datajunction_server.database.attributetype import ColumnAttribute
 from datajunction_server.database.availabilitystate import AvailabilityState
@@ -449,9 +449,13 @@ class Node(Base):
                 Node.name.in_(names),  # type: ignore
             )
         if fragment:
-            statement = statement.where(
-                Node.name.like(f"%{fragment}%"),  # type: ignore
+            statement = statement.join(NodeRevision, Node.current).where(
+                or_(
+                    Node.name.like(f"%{fragment}%"),  # type: ignore
+                    NodeRevision.display_name.ilike(f"%{fragment}%"),  # type: ignore
+                ),
             )
         if node_types:
             statement = statement.where(Node.type.in_(node_types))
         if edited_by:
@@ -542,7 +546,15 @@ class NodeRevision(
     """
     __tablename__ = "noderevision"
-    __table_args__ = (UniqueConstraint("version", "node_id"),)
+    __table_args__ = (
+        UniqueConstraint("version", "node_id"),
+        Index(
+            "ix_noderevision_display_name",
+            "display_name",
+            postgresql_using="gin",
+            postgresql_ops={"display_name": "gin_trgm_ops"},
+        ),
+    )
     id: Mapped[int] = mapped_column(
         sa.BigInteger().with_variant(sa.Integer, "sqlite"),

@@ -0,0 +1,31 @@
+"""
+Module related to all things notifications
+"""
+from typing import List, Optional
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from datajunction_server.database.notification_preference import NotificationPreference
+from datajunction_server.database.history import EntityType
+async def get_notification_preferences(
+    session: AsyncSession,
+    user: str,
+    entity_name: Optional[str] = None,
+    entity_type: Optional[EntityType] = None,
+) -> List[NotificationPreference]:
+    """
+    Get all notification preferences for a user, optionally filtering to a specific entity name and/or entity type
+    """
+    statement = select(NotificationPreference).where(
+        NotificationPreference.user == user,
+    )
+    if entity_name:
+        statement = statement.where(NotificationPreference.entity_name == entity_name)
+    if entity_type:
+        statement = statement.where(NotificationPreference.entity_type == entity_type)
+    result = await session.execute(statement)
+    return result.scalars().all()

@@ -290,6 +290,52 @@ async def test_find_by_fragment(
         },
     ]
+    query = """
+    {
+        findNodes(fragment: "Repair Ord") {
+            name
+            current {
+                displayName
+            }
+        }
+    }
+    """
+    response = await module__client_with_roads.post("/graphql", json={"query": query})
+    assert response.status_code == 200
+    data = response.json()
+    assert data["data"]["findNodes"] == [
+        {
+            "current": {
+                "displayName": "Avg Repair Order Discounts",
+            },
+            "name": "default.avg_repair_order_discounts",
+        },
+        {
+            "current": {
+                "displayName": "Total Repair Order Discounts",
+            },
+            "name": "default.total_repair_order_discounts",
+        },
+        {
+            "current": {
+                "displayName": "Num Repair Orders",
+            },
+            "name": "default.num_repair_orders",
+        },
+        {
+            "current": {
+                "displayName": "Repair Orders Fact",
+            },
+            "name": "default.repair_orders_fact",
+        },
+        {
+            "current": {
+                "displayName": "Repair Order",
+            },
+            "name": "default.repair_order",
+        },
+    ]
 @pytest.mark.asyncio
 async def test_find_by_names(

@@ -30,7 +30,7 @@ from fastapi_cache import FastAPICache
 from fastapi_cache.backends.inmemory import InMemoryBackend
 from httpx import AsyncClient
 from pytest_mock import MockerFixture
-from sqlalchemy import StaticPool, insert
+from sqlalchemy import StaticPool, insert, text
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 from testcontainers.core.waiting_utils import wait_for_logs
 from testcontainers.postgres import PostgresContainer
@@ -178,6 +178,7 @@ async def session(
         poolclass=StaticPool,
     )
     async with engine.begin() as conn:
+        await conn.execute(text("CREATE EXTENSION IF NOT EXISTS pg_trgm;"))
         await conn.run_sync(Base.metadata.create_all)
     async_session_factory = async_sessionmaker(
         bind=engine,
@@ -774,6 +775,7 @@ async def module__session(
         poolclass=StaticPool,
     )
     async with engine.begin() as conn:
+        await conn.execute(text("CREATE EXTENSION IF NOT EXISTS pg_trgm;"))
         await conn.run_sync(Base.metadata.create_all)
     async_session_factory = async_sessionmaker(
         bind=engine,

@@ -1,5 +0,0 @@
-"""
-Version for Hatch
-"""
-__version__ = "0.0.1a91"

datajunction-server 0.0.1a91__tar.gz → 0.0.1a91.dev0__tar.gz

datajunction-server 0.0.1a91tar.gz → 0.0.1a91.dev0tar.gz