datajunction-server 0.0.1a86.dev0__tar.gz → 0.0.1a87__tar.gz

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/PKG-INFO

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

datajunction_server-0.0.1a87/datajunction_server/__about__.py

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

datajunction_server-0.0.1a87/datajunction_server/alembic/versions/2025_02_11_1619-c3d5f327296c_notificationpreferences.py

@@ -0,0 +1,81 @@
+"""notificationpreferences
+
+Revision ID: c3d5f327296c
+Revises: bec3296d7537
+Create Date: 2025-02-11 16:19:35.918790+00:00
+
+"""
+# pylint: disable=no-member, invalid-name, missing-function-docstring, unused-import, no-name-in-module
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "c3d5f327296c"
+down_revision = "bec3296d7537"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "notificationpreferences",
+        sa.Column("id", sa.BigInteger(), nullable=False),
+        sa.Column(
+            "entity_type",
+            sa.Enum(
+                "ATTRIBUTE",
+                "AVAILABILITY",
+                "BACKFILL",
+                "CATALOG",
+                "COLUMN_ATTRIBUTE",
+                "DEPENDENCY",
+                "ENGINE",
+                "LINK",
+                "MATERIALIZATION",
+                "NAMESPACE",
+                "NODE",
+                "PARTITION",
+                "QUERY",
+                "TAG",
+                name="notification_entitytype",
+            ),
+            nullable=False,
+        ),
+        sa.Column("entity_name", sa.String(), nullable=False),
+        sa.Column(
+            "activity_types",
+            sa.ARRAY(
+                sa.Enum(
+                    "CREATE",
+                    "DELETE",
+                    "RESTORE",
+                    "UPDATE",
+                    "REFRESH",
+                    "TAG",
+                    "SET_ATTRIBUTE",
+                    "STATUS_CHANGE",
+                    name="notification_activitytype",
+                ),
+            ),
+            nullable=False,
+        ),
+        sa.Column(
+            "user_id",
+            sa.BigInteger().with_variant(sa.Integer(), "sqlite"),
+            nullable=False,
+        ),
+        sa.Column("alert_types", sa.ARRAY(sa.String()), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["user_id"],
+            ["users.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("entity_name", "entity_type", name="uix_entity_type_name"),
+    )
+
+
+def downgrade():
+    op.drop_table("notificationpreferences")

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/api/access/authentication/basic.py

@@ -73,7 +73,10 @@ async def login(
         password=form_data.password,
         session=session,
     )
-    response = Response(status_code=HTTPStatus.OK)
+    response = JSONResponse(
+        content={"message": "Logged in successfully"},
+        status_code=HTTPStatus.OK,
+    )
     response.set_cookie(
         AUTH_COOKIE,
         create_token(

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/api/data.py

@@ -15,7 +15,7 @@ from datajunction_server.api.helpers import (
     build_sql_for_multiple_metrics,
     query_event_stream,
 )
-from datajunction_server.api.notification import get_notifier
+from datajunction_server.api.notifications import get_notifier
 from datajunction_server.api.sql import get_node_sql
 from datajunction_server.database.availabilitystate import AvailabilityState
 from datajunction_server.database.history import ActivityType, EntityType, History

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/api/main.py

@@ -36,6 +36,7 @@ from datajunction_server.api import (
     metrics,
     namespaces,
     nodes,
+    notifications,
     sql,
     tags,
     users,
@@ -102,6 +103,7 @@ app.include_router(graphql_app, prefix="/graphql")
 app.include_router(whoami.router)
 app.include_router(users.router)
 app.include_router(basic.router)
+app.include_router(notifications.router)
 
 
 @app.on_event("startup")

datajunction_server-0.0.1a87/datajunction_server/api/notifications.py

@@ -0,0 +1,124 @@
+"""Dependency for notifications"""
+
+import logging
+from http import HTTPStatus
+from typing import Annotated, Optional
+
+from fastapi import Body, Depends
+from fastapi.responses import JSONResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+
+from datajunction_server.database.history import ActivityType, EntityType, History
+from datajunction_server.database.notification_preference import NotificationPreference
+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.utils import get_and_update_current_user, get_session
+
+router = SecureAPIRouter(tags=["notifications"])
+_logger = logging.getLogger(__name__)
+
+
+def get_notifier():
+    """Returns a method for sending notifications for an event"""
+
+    def notify(event: History):
+        """Send a notification for an event"""
+        _logger.debug("Sending notification for event %s", event)
+
+    return notify
+
+
+@router.post("/notifications/subscribe")
+async def subscribe(
+    entity_type: Annotated[EntityType, Body()],
+    entity_name: Annotated[str, Body()],
+    activity_types: list[ActivityType],
+    alert_types: list[str],
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_and_update_current_user),
+) -> JSONResponse:
+    """Subscribes to notificaitons by upserting a notification preference"""
+    session.add(
+        NotificationPreference(
+            entity_type=entity_type,
+            entity_name=entity_name,
+            activity_types=activity_types,
+            alert_types=alert_types,
+            user=current_user,
+        ),
+    )
+    await session.commit()
+    return JSONResponse(
+        status_code=201,
+        content={
+            "message": (
+                f"Notification preferences successfully saved for {entity_name}"
+            ),
+        },
+    )
+
+
+@router.delete("/notifications/unsubscribe")
+async def unsubscribe(
+    entity_type: EntityType,
+    entity_name: str,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_and_update_current_user),
+) -> JSONResponse:
+    """Unsubscribes from notifications by deleting a notification preference"""
+    result = await session.execute(
+        select(NotificationPreference).where(
+            NotificationPreference.entity_type == entity_type,
+            NotificationPreference.entity_name == entity_name,
+            NotificationPreference.user_id == current_user.id,
+        ),
+    )
+    notification_preference = result.scalars().first()
+
+    if not notification_preference:
+        raise DJDoesNotExistException(
+            message=f"No notification preference found for {entity_name}",
+            http_status_code=HTTPStatus.NOT_FOUND,
+        )
+    await session.delete(notification_preference)
+    await session.commit()
+    return JSONResponse(
+        status_code=200,
+        content={
+            "message": (
+                f"Notification preferences successfully removed for {entity_name}"
+            ),
+        },
+    )
+
+
+@router.get("/notifications/")
+async def get_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,
+    )
+    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 = [
+        {
+            "entity_type": pref.entity_type,
+            "entity_name": pref.entity_name,
+            "activity_types": pref.activity_types,
+            "user_id": pref.user.id,
+            "username": pref.user.username,
+            "alert_types": pref.alert_types,
+        }
+        for pref in result.scalars().all()
+    ]
+    return JSONResponse(content=notification_preferences)

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/database/__init__.py

@@ -12,6 +12,7 @@ __all__ = [
     "Node",
     "NodeNamespace",
     "NodeRevision",
+    "NotificationPreference",
     "Partition",
     "QueryRequest",
     "Table",
@@ -29,6 +30,7 @@ from datajunction_server.database.engine import Engine
 from datajunction_server.database.measure import Measure
 from datajunction_server.database.namespace import NodeNamespace
 from datajunction_server.database.node import Node, NodeRevision
+from datajunction_server.database.notification_preference import NotificationPreference
 from datajunction_server.database.partition import Partition
 from datajunction_server.database.queryrequest import QueryRequest
 from datajunction_server.database.tag import Tag

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/database/dimensionlink.py

@@ -140,16 +140,30 @@ class DimensionLink(Base):
         return mapping
 
     @hybrid_property
-    def foreign_keys(self) -> Dict[str, str]:
+    def foreign_keys(self) -> Dict[str, str | None]:
         """
         Returns a mapping from the foreign key column(s) on the origin node to
         the primary key column(s) on the dimension node. The dict values are column names.
         """
-        return {
+        from datajunction_server.sql.parsing.backends.antlr4 import ast
+
+        # Build equality operator-based mappings
+        join_asts = self.joins()
+        mapping: dict[str, str | None] = {
             right.identifier(): left.identifier()
             for left, right in self.foreign_key_mapping().items()
         }
 
+        # Add remaining foreign key references without an equality comparison
+        columns = [col.identifier() for col in join_asts[0].find_all(ast.Column)]
+        foreign_key_refs = [
+            col for col in columns if col.startswith(self.node_revision.name)
+        ]
+        for foreign_key in foreign_key_refs:
+            if foreign_key not in mapping:
+                mapping[foreign_key] = None
+        return mapping
+
     @hybrid_property
     def foreign_key_column_names(self) -> Set[str]:
         """

datajunction_server-0.0.1a87/datajunction_server/database/notification_preference.py

@@ -0,0 +1,60 @@
+"""History database schema."""
+
+from datetime import datetime, timezone
+from functools import partial
+
+from sqlalchemy import (
+    ARRAY,
+    BigInteger,
+    DateTime,
+    Enum,
+    ForeignKey,
+    Integer,
+    String,
+    UniqueConstraint,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from datajunction_server.database.base import Base
+from datajunction_server.database.history import ActivityType, EntityType
+from datajunction_server.database.user import User
+from datajunction_server.typing import UTCDatetime
+
+
+class NotificationPreference(Base):  # pylint: disable=too-few-public-methods
+    """
+    User notification preferences for a specific entity and activity type.
+    """
+
+    __tablename__ = "notificationpreferences"
+    __table_args__ = (
+        UniqueConstraint("entity_name", "entity_type", name="uix_entity_type_name"),
+    )
+
+    id: Mapped[int] = mapped_column(
+        BigInteger().with_variant(Integer, "sqlite"),
+        primary_key=True,
+    )
+    entity_type: Mapped[EntityType] = mapped_column(
+        Enum(EntityType, name="notification_entitytype"),
+    )
+    entity_name: Mapped[str] = mapped_column(String)
+    activity_types: Mapped[list[ActivityType]] = mapped_column(
+        ARRAY(
+            Enum(ActivityType, name="notification_activitytype"),
+        ),  # Use ARRAY of enums
+        default=list,
+    )
+    user_id: Mapped[int] = mapped_column(
+        ForeignKey("users.id"),
+        nullable=False,
+    )
+    user: Mapped["User"] = relationship(
+        "User",
+        back_populates="notification_preferences",
+    )
+    alert_types: Mapped[list[str]] = mapped_column(ARRAY(String), default=list)
+    created_at: Mapped[UTCDatetime] = mapped_column(
+        DateTime(timezone=True),
+        insert_default=partial(datetime.now, timezone.utc),
+    )

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/database/user.py

@@ -12,6 +12,9 @@ from datajunction_server.enum import StrEnum
 if TYPE_CHECKING:
     from datajunction_server.database.collection import Collection
     from datajunction_server.database.node import Node, NodeRevision
+    from datajunction_server.database.notification_preference import (
+        NotificationPreference,
+    )
     from datajunction_server.database.tag import Tag
 
 
@@ -65,6 +68,10 @@ class User(Base):
         foreign_keys="Tag.created_by_id",
         lazy="joined",
     )
+    notification_preferences: Mapped[list["NotificationPreference"]] = relationship(
+        "NotificationPreference",
+        back_populates="user",
+    )
 
     @classmethod
     async def get_by_username(

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/internal/nodes.py

@@ -1148,10 +1148,11 @@ async def create_new_revision_from_existing(
         and data.columns
         and ({col.identifier() for col in old_revision.columns} != data.columns)
     )
-    pk_changes = (
-        data
-        and data.primary_key
-        and {col.name for col in old_revision.primary_key()} != set(data.primary_key)
+    pk_changes = data and (
+        data.primary_key == []
+        and len(old_revision.primary_key())
+        or {col.name for col in old_revision.primary_key()}
+        != set(data.primary_key or [])
     )
     required_dim_changes = (
         data
@@ -1282,7 +1283,7 @@ async def create_new_revision_from_existing(
             new_revision.columns[0].display_name = new_revision.display_name
 
         # Update the primary key if one was set in the input
-        if data is not None and data.primary_key:
+        if data is not None and (data.primary_key or data.primary_key == []):
             pk_attribute = (
                 await session.execute(
                     select(AttributeType).where(

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/datajunction_server/models/dimensionlink.py

@@ -62,7 +62,7 @@ class LinkDimensionOutput(BaseModel):
     join_sql: str
     join_cardinality: Optional[JoinCardinality]
     role: Optional[str]
-    foreign_keys: Dict[str, str]
+    foreign_keys: Dict[str, str | None]
 
     class Config:
         orm_mode = True

{datajunction_server-0.0.1a86.dev0 → datajunction_server-0.0.1a87}/tests/api/dimension_links_test.py

@@ -405,7 +405,10 @@ async def test_link_complex_dimension_with_role(
             "INT)",
             "join_type": "left",
             "role": "user_windowed",
-            "foreign_keys": {"default.events.user_id": "default.users.user_id"},
+            "foreign_keys": {
+                "default.events.event_start_date": None,
+                "default.events.user_id": "default.users.user_id",
+            },
         },
     ]
 

datajunction_server-0.0.1a87/tests/api/notifications_test.py

@@ -0,0 +1,176 @@
+"""Tests for notifications router"""
+
+import unittest
+from unittest import mock
+
+import pytest
+from httpx import AsyncClient
+
+from datajunction_server.api.notifications import get_notifier
+from datajunction_server.database.history import ActivityType, EntityType, History
+
+
+class TestNotification(unittest.TestCase):
+    """Test sending notifications"""
+
+    @mock.patch("datajunction_server.api.notifications._logger")
+    def test_notification(self, mock_logger):
+        """Test the get_notifier dependency"""
+        notify = get_notifier()
+        event = History(
+            id=1,
+            entity_name="bar",
+            entity_type=EntityType.NODE,
+            activity_type=ActivityType.CREATE,
+        )
+        notify(event)
+
+        mock_logger.debug.assert_any_call(
+            "Sending notification for event %s",
+            event,
+        )
+
+
+@pytest.mark.asyncio
+async def test_notification_subscription(
+    module__client: AsyncClient,
+) -> None:
+    """
+    Test subscribing to notifications.
+    """
+    response = await module__client.post(
+        "/notifications/subscribe",
+        json={
+            "entity_name": "some_node_name",
+            "entity_type": EntityType.NODE,
+            "activity_types": [ActivityType.DELETE],
+            "alert_types": ["slack", "email"],
+        },
+    )
+    assert response.status_code == 201
+    assert response.json() == {
+        "message": "Notification preferences successfully saved for some_node_name",
+    }
+
+
+@pytest.mark.asyncio
+async def test_notification_preferences(
+    module__client: AsyncClient,
+) -> None:
+    """
+    Test retrieving notification preferences.
+    """
+    response = await module__client.post(
+        "/notifications/subscribe",
+        json={
+            "entity_type": EntityType.NODE,
+            "entity_name": "some_node_name2",
+            "activity_types": [ActivityType.REFRESH],
+            "alert_types": ["slack", "email"],
+        },
+    )
+    assert response.status_code == 201
+    response = await module__client.get(
+        "/notifications/",
+        params={"entity_name": "some_node_name2"},
+    )
+    assert response.status_code == 200
+    assert len(response.json()) > 0
+    assert response.json()[0]["entity_name"] == "some_node_name2"
+    assert response.json()[0]["username"] == "dj"
+
+
+@pytest.mark.asyncio
+async def test_notification_preferences_with_filters(
+    module__client: AsyncClient,
+) -> None:
+    """
+    Test retrieving notification preferences with filters.
+    """
+    await module__client.post(
+        "/notifications/subscribe",
+        json={
+            "entity_type": EntityType.NODE,
+            "entity_name": "name1",
+            "activity_types": [ActivityType.STATUS_CHANGE],
+            "alert_types": ["slack", "email"],
+        },
+    )
+    await module__client.post(
+        "/notifications/subscribe",
+        json={
+            "entity_name": "name2",
+            "entity_type": EntityType.NODE,
+            "activity_types": [ActivityType.DELETE],
+            "alert_types": ["slack", "email"],
+        },
+    )
+    response = await module__client.get(
+        "/notifications/?entity_name=name1",
+    )
+    assert response.status_code == 200
+    assert len(response.json()) == 1
+    assert response.json()[0]["entity_name"] == "name1"
+
+    response = await module__client.get(
+        "/notifications/?entity_type=node",
+    )
+    assert response.status_code == 200
+    assert len(response.json()) > 1
+    assert response.json()[0]["entity_type"] == "node"
+
+
+@pytest.mark.asyncio
+async def test_notification_unsubscribe(
+    module__client: AsyncClient,
+) -> None:
+    """
+    Test unsubscribing from notifications.
+    """
+    # Subscribe
+    response = await module__client.post(
+        "/notifications/subscribe",
+        json={
+            "entity_name": "some_node_name3",
+            "entity_type": EntityType.NODE,
+            "activity_types": [ActivityType.DELETE],
+            "alert_types": ["slack", "email"],
+        },
+    )
+    assert response.status_code == 201
+
+    # Unsubscribe
+    response = await module__client.delete(
+        "/notifications/unsubscribe",
+        params={
+            "entity_type": EntityType.NODE,
+            "entity_name": "some_node_name3",
+        },
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "message": "Notification preferences successfully removed for some_node_name3",
+    }
+
+    # Verify that the notification preference is actually removed
+    response = await module__client.get("/notifications/")
+    assert response.status_code == 200
+    assert all(pref["entity_name"] != "some_node_name3" for pref in response.json())
+
+
+@pytest.mark.asyncio
+async def test_notification_unsubscribe_not_found(
+    module__client: AsyncClient,
+) -> None:
+    """
+    Test notification preference not found when unsubscribing
+    """
+    # Unsubscribe to a notification that doesn't exist
+    response = await module__client.delete(
+        "/notifications/unsubscribe",
+        params={
+            "entity_type": EntityType.NODE,
+            "entity_name": "does_not_exist",
+        },
+    )
+    assert response.status_code == 404

datajunction_server-0.0.1a86.dev0/datajunction_server/__about__.py

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

datajunction_server-0.0.1a86.dev0/datajunction_server/api/notification.py

@@ -1,17 +0,0 @@
-"""Dependency for notifications"""
-
-import logging
-
-from datajunction_server.database.history import History
-
-_logger = logging.getLogger(__name__)
-
-
-def get_notifier():
-    """Returns a method for sending notifications for an event"""
-
-    def notify(event: History):
-        """Send a notification for an event"""
-        _logger.debug("Sending notification for event %s", event)
-
-    return notify

datajunction_server-0.0.1a86.dev0/tests/api/notification_test.py

@@ -1,28 +0,0 @@
-"""Tests for notification dependency injection"""
-
-import unittest
-from unittest.mock import patch
-
-from datajunction_server.api.notification import get_notifier
-from datajunction_server.database.history import ActivityType, EntityType, History
-
-
-class TestNotification(unittest.TestCase):
-    """Test sending notifications"""
-
-    @patch("datajunction_server.api.notification._logger")
-    def test_notify(self, mock_logger):
-        """Test the get_notifier dependency"""
-        notify = get_notifier()
-        event = History(
-            id=1,
-            entity_name="bar",
-            entity_type=EntityType.NODE,
-            activity_type=ActivityType.CREATE,
-        )
-        notify(event)
-
-        mock_logger.debug.assert_any_call(
-            "Sending notification for event %s",
-            event,
-        )