Merge pull request #82 from Sigmapitech/feat/issue-79/(re)actions

Author: Sigmanificient

HOW_TO_CONTRIBUTE.md

@@ -0,0 +1,89 @@
+Here’s a concise `HOW_TO_CONTRIBUTE.md` for adding a new OAuth service to your project based on the Discord example:
+
+---
+
+# How to Contribute a New OAuth Service
+
+This guide explains how to add a new OAuth service to our platform using the existing Discord integration as a reference.
+
+## 1. Create a Config Model
+
+In your service module, create a `Config` Pydantic model that defines the OAuth configuration:
+
+```python
+from pydantic import BaseModel
+
+class Config(BaseModel):
+    service: str = "google"
+    client_id: str
+    client_secret: str
+    auth_base: str = "..."
+    token_url: str = "..."
+    api_base: str = "..."
+    api_resource: str = "..."
+    profile_endpoint: str = "..."
+    redirect_uri: str = "..."
+    scope: str = "..."
+    pkce: bool = True
+```
+
+* Set `service` to a unique identifier for the platform.
+* Specify the authorization URL (`auth_base`), token URL (`token_url`), API endpoints, and scopes.
+* `redirect_uri` should point to your API route for handling the callback.
+
+## 2. Instantiate the OAuth Provider
+
+Use the shared `OAuthProvider` class:
+
+```python
+from fastapi import APIRouter
+import pathlib
+from .oauth_base import OAuthProvider
+
+router = APIRouter(prefix="/[my_service]", tags=["[my_service]"])
+
+provider = OAuthProvider(
+    package=__package__,
+    config_model=Config,
+    icon=(pathlib.Path(__file__).parent / "icon.svg").read_text()
+)
+```
+
+* The `icon` will be displayed in the frontend service cards.
+
+## 3. Add API Routes
+
+Define FastAPI routes to handle connecting, authentication, token refresh, and user info:
+
+```python
+@router.get("/connect")
+async def google_connect(token: str, platform: str):
+    return await provider.connect(token, platform)
+
+@router.get("/auth")
+async def google_auth(code: str, state: str, db=Depends(get_session)):
+    return await provider.auth(code, state, db)
+
+@router.get("/refresh")
+async def google_refresh(user=Depends(get_current_user), db=Depends(get_session)):
+    return await provider.refresh(user, db)
+
+@router.get("/me")
+async def google_me(user=Depends(get_current_user), db=Depends(get_session)):
+    return await provider.me(user, db)
+```
+
+* `/connect` initiates the OAuth connection.
+* `/auth` handles the callback from the OAuth provider.
+* `/refresh` refreshes the access token.
+* `/me` retrieves the current user’s profile info from the service.
+
+## 4. Add Service Icon
+
+Place an SVG icon named `icon.svg` in the service module folder. This will be displayed in the frontend cards for connecting services.
+
+## 5. Test
+
+1. Login in to the area
+2. Go to `/services`
+3. You should see you newly added service and be able to connect to it

back/app/db/models/__init__.py

@@ -1,4 +1,15 @@
+from .interaction import Interaction
+from .oauth import OAuthToken
+from .service import Service
 from .user import User
 from .workflow import Workflow, WorkflowNode, WorkflowNodeConfig
 
-__all__ = ("User", "Workflow", "WorkflowNode", "WorkflowNodeConfig")
+__all__ = (
+    "Interaction",
+    "OAuthToken",
+    "Service",
+    "User",
+    "Workflow",
+    "WorkflowNode",
+    "WorkflowNodeConfig",
+)

back/app/db/models/interaction.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Column, Integer, String
+
+from ..base import Base
+
+
+class Interaction(Base):
+    __tablename__ = "interaction"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(64), nullable=False)

back/app/db/models/oauth.py

@@ -1,19 +1,19 @@
-from datetime import datetime
-
-from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String
 from sqlalchemy.orm import relationship
 
 from ..base import Base
 
 
-class UserToken(Base):
-    __tablename__ = "user_tokens"
+class OAuthToken(Base):
+    __tablename__ = "oauth_token"
 
     id = Column(Integer, primary_key=True)
-    user_id = Column(ForeignKey("user.id"), nullable=False)
-    service = Column(String(100), nullable=False)  # e.g. "spotify"
-    access_token = Column(Text, nullable=False)
-    refresh_token = Column(Text, nullable=True)
+    owner_id = Column(ForeignKey("user.id"), nullable=False)
+    access_token = Column(String(128), nullable=False)
+    refresh_token = Column(String(128), nullable=True)
+
+    service_id = Column(Integer, ForeignKey("service.id"), nullable=False)
+
     scope = Column(String(512), nullable=True)
     expires_at = Column(DateTime, nullable=True)
 

back/app/db/models/service.py

@@ -0,0 +1,10 @@
+from sqlalchemy import Column, Integer, String
+
+from ..base import Base
+
+
+class Service(Base):
+    __tablename__ = "service"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(32), index=True)

back/app/db/models/user.py

@@ -10,11 +10,14 @@ class User(Base):
     __tablename__ = "user"
 
     id = Column(Integer, primary_key=True, index=True)
-    email = Column(String, unique=True, index=True, nullable=False)
-    auth = Column(String, nullable=False)
-    name = Column(String, nullable=False)
+    name = Column(String(64), nullable=False)
+
+    email = Column(String(256), unique=True, index=True, nullable=False)
+    auth = Column(String(256), nullable=False)
+
     created_at = Column(DateTime, default=datetime.now)
     updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
     workflows = relationship(
         "Workflow",
         back_populates="owner",
@@ -23,7 +26,7 @@ class User(Base):
     )
 
     tokens = relationship(
-        "UserToken",
+        "OAuthToken",
         back_populates="user",
         cascade="all, delete-orphan",
         passive_deletes=True,

back/app/db/models/workflow.py

@@ -8,8 +8,9 @@ class Workflow(Base):
     __tablename__ = "workflow"
 
     id = Column(Integer, primary_key=True, index=True)
-    name = Column(String, index=True)
-    description = Column(String, index=True, nullable=True)
+    name = Column(String(32), index=True)
+
+    description = Column(String(512), index=True, nullable=True)
     owner_id = Column(Integer, ForeignKey("user.id", ondelete="CASCADE"))
 
     nodes = relationship(
@@ -30,6 +31,8 @@ class WorkflowNode(Base):
         Integer, ForeignKey("workflow.id", ondelete="CASCADE")
     )
 
+    interaction_id = Column(Integer, ForeignKey("interaction.id"))
+
     config = relationship(
         "WorkflowNodeConfig",
         back_populates="node",
@@ -66,37 +69,15 @@ class WorkflowNodeConfig(Base):
     node_id = Column(
         Integer, ForeignKey("workflow_node.id", ondelete="CASCADE")
     )
-    key = Column(String, index=True)
-    value = Column(String, index=True)
+
+    key = Column(String(32), index=True)
+    value = Column(String(128), index=True)
 
     node = relationship("WorkflowNode", back_populates="config")
 
 
 class WorkflowEdge(Base):
-    """
-    Represents a directed connection between two WorkflowNode entities in the workflow graph.
-
-    This SQLAlchemy ORM model stores edges that originate from one node and point to another.
-    A uniqueness constraint on `to_node_id` guarantees that a node can have at most one
-    incoming edge, while a single node may emit multiple outgoing edges. Deleting a node
-    cascades to its associated edges.
-
-    Attributes:
-        id (int): Primary key identifier of the edge.
-        from_node_id (int): Foreign key to the source WorkflowNode (workflow_node.id), cascades on delete.
-        to_node_id (int): Foreign key to the target WorkflowNode (workflow_node.id), cascades on delete.
-                          Uniquely constrained to enforce at most one incoming edge per node.
-
-    Relationships:
-        from_node (WorkflowNode): Source node; back-populates 'outgoing_edges'.
-        to_node (WorkflowNode): Target node; back-populates 'incoming_edge'.
-
-    Constraints and behavior:
-        - Directed edge: from_node -> to_node.
-        - ondelete="CASCADE" ensures edges are removed when their associated nodes are deleted.
-        - Unique to_node_id enforces in-degree <= 1, enabling a one-to-many (source->edges) and
-          one-to-one (target<-edge) structure.
-    """
+    """Represents a directed connection between two WorkflowNode its graph."""
 
     __tablename__ = "workflow_edge"
 

back/app/routes/caldav/google.py

@@ -12,7 +12,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ...db import get_session
-from ...db.models.oauth import UserToken
+from ...db.models.oauth import OAuthToken
 from ...security.deps import get_current_user
 from ..oauth_base import OAuthProvider
 
@@ -51,11 +51,11 @@ class Config(BaseModel):
 )
 
 
-async def _get_token(user_id: int, db: AsyncSession) -> UserToken:
+async def _get_token(user_id: int, db: AsyncSession) -> OAuthToken:
     token = await db.scalar(
-        select(UserToken).where(
-            UserToken.user_id == user_id,
-            UserToken.service == provider.cfg.service,
+        select(OAuthToken).where(
+            OAuthToken.owner_id == user_id,
+            OAuthToken.service == provider.cfg.service,
         )
     )
     if not token:

back/app/routes/gmail/gmail.py

@@ -11,7 +11,7 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ...db import get_session
-from ...db.models.oauth import UserToken
+from ...db.models.oauth import OAuthToken
 from ...security.deps import get_current_user
 from ..oauth_base import OAuthProvider
 
@@ -91,10 +91,10 @@ def _b64url_decode(data: str) -> bytes:
 
 async def _get_gmail_token(
     user_id: int, db: AsyncSession
-) -> Optional[UserToken]:
+) -> Optional[OAuthToken]:
     return await db.scalar(
-        select(UserToken).where(
-            UserToken.user_id == user_id, UserToken.service == "gmail"
+        select(OAuthToken).where(
+            OAuthToken.owner_id == user_id, OAuthToken.service == "gmail"
         )
     )
 

back/app/routes/oauth_base.py

@@ -16,7 +16,7 @@
 
 from ..config import get_package_config
 from ..db.crud import users
-from ..db.models.oauth import UserToken
+from ..db.models.oauth import OAuthToken
 from ..db.models.user import User
 from ..security.jwt import decode_access_token
 
@@ -171,7 +171,7 @@ async def auth(self, code: str, state: str, db: AsyncSession):
 
         tokens = resp.json()
 
-        token = UserToken(
+        token = OAuthToken(
             user_id=user.id,
             service=self.cfg.service,
             access_token=tokens.get("access_token"),
@@ -207,9 +207,9 @@ async def auth(self, code: str, state: str, db: AsyncSession):
 
     async def refresh(self, user: User, db: AsyncSession):
         token = await db.scalar(
-            select(UserToken).where(
-                UserToken.user_id == user.id,
-                UserToken.service == self.cfg.service,
+            select(OAuthToken).where(
+                OAuthToken.owner_id == user.id,
+                OAuthToken.service == self.cfg.service,
             )
         )
         if not token:
@@ -258,9 +258,9 @@ async def refresh(self, user: User, db: AsyncSession):
 
     async def me(self, user: User, db: AsyncSession):
         token = await db.scalar(
-            select(UserToken).where(
-                UserToken.user_id == user.id,
-                UserToken.service == self.cfg.service,
+            select(OAuthToken).where(
+                OAuthToken.owner_id == user.id,
+                OAuthToken.service == self.cfg.service,
             )
         )
         if not token: