chores: Updates proper references and reorganizes structs

Author: ruiconti

src/auth/adapters/email_sender.py

@@ -1,8 +1,8 @@
 import emails
 import logging
 
-from craftship.core.ports.email_sender import AbstractEmailSender
-from craftship.auth import config
+from src.core.ports.email_sender import AbstractEmailSender
+from src.auth import config
 
 
 class EmailSender(AbstractEmailSender):
@@ -28,5 +28,5 @@ def send_email(
         )
         logging.info(f"Sending email to {email_to} with subject: {subject}")
         response = message.send(to=email_to, smtp=self.smtp_options)
-        logging.info(f"Email sent, response: {response}")
+        logging.info(f"Email sent, service response: {response}")
         return response.status_code

src/auth/adapters/orm.py

@@ -18,7 +18,7 @@
 )
 from sqlalchemy.orm import events, mapper, relationship
 
-from craftship.auth.domain import model
+from src.auth.domain import model
 
 
 users: Callable[[MetaData], Table] = lambda metadata: Table(

src/auth/bootstrap.py

@@ -1,7 +1,7 @@
-from craftship.core.ports.unit_of_work import AbstractUnitOfWork
-from craftship.core.ports.email_sender import AbstractEmailSender
-from craftship.auth.services import unit_of_work
-from craftship.auth.adapters import email_sender
+from src.core.ports.unit_of_work import AbstractUnitOfWork
+from src.core.ports.email_sender import AbstractEmailSender
+from src.auth.services import unit_of_work
+from src.auth.adapters import email_sender
 
 
 def create(

src/auth/config.py

@@ -4,14 +4,15 @@
 
 SCHEMA_PATHS = ("apolo/auth/entrypoint/graphql/schema.graphql",)
 
+# [TODO] These should be exported to ENVARs
 DEFAULT_TOKEN_EXPIRATION = 60
 DEFAULT_JWT_SECRET_KEY = base64.b64encode(
     uuid.uuid4().hex[:7].encode("utf-8")
 ).decode("utf-8")
 JWT_ALGORITHM = "HS256"
 AUTH_TYPE = "Bearer"
 EMAIL_TEMPLATES_DIR = "apolo/auth/services/email-templates"
-SUBJECT_PWD_CHANGE = "Troca de Senha Apolo NPL"
+SUBJECT_PWD_CHANGE = "Password Change Request"
 
 
 def get_jwt_secret_key() -> str:

src/auth/domain/model.py

@@ -3,6 +3,7 @@
 import jwt
 from dataclasses import dataclass
 from typing import Any, Optional, Set, List
+# TODO we shouldn't be importing any of these below here
 from passlib.context import CryptContext
 from datetime import datetime, timedelta
 from string import Template
@@ -134,6 +135,7 @@ def generate_password_reset_token(self) -> bytes:
         return encoded_jwt.decode("utf-8")
 
     def generate_reset_pwd_email(self, client_url: str) -> str:
+        # TODO This method should be inside a proper adapter
         with open(Path(config.EMAIL_TEMPLATES_DIR) / "reset_pwd.html") as f:
             template_str = f.read()
 

src/auth/entrypoint/graphql/directives.py

@@ -12,8 +12,8 @@
 )
 
 
-from craftship.auth.entrypoint import uow
-from craftship.auth.services import handlers
+from src.auth.entrypoint import uow
+from src.auth.services import handlers
 
 
 class NeedsPermissionDirective(SchemaDirectiveVisitor):

src/auth/entrypoint/graphql/middlewares.py

@@ -2,8 +2,8 @@
 from ariadne.types import GraphQLError, GraphQLResolveInfo, Resolver
 from starlette.requests import Headers, HTTPConnection
 
-from craftship.auth import utils
-from craftship.core.exceptions import resolve_error, ApoloException
+from src.auth import utils
+from src.core.exceptions import resolve_error, ApoloException
 
 
 class MissingAuthHeader(ApoloException):

src/auth/entrypoint/graphql/resolvers.py

@@ -7,11 +7,11 @@
     convert_kwargs_to_snake_case,
 )
 
-from craftship.core.exceptions import resolve_error
-from craftship.auth.services import handlers
-from craftship.auth.entrypoint import uow, email_sender
-from craftship.auth import config, views
-from craftship.auth import utils
+from src.core.exceptions import resolve_error
+from src.auth.services import handlers
+from src.auth.entrypoint import uow, email_sender
+from src.auth import config, views
+from src.auth import utils
 
 
 query = QueryType()

src/auth/services/handlers.py

@@ -1,44 +1,45 @@
 from typing import Dict, List, Tuple
 
-from craftship.auth.domain import model
-from craftship.auth.services import unit_of_work
-from craftship.auth.adapters import email_sender
-from craftship.auth import config
-from craftship.auth import utils
-from craftship.core.exceptions import ApoloException
+from src.auth.domain import model
+from src.auth.services import unit_of_work
+from src.auth.adapters import email_sender
+from src.auth import config
+from src.auth import utils
 
+from src.core.exceptions import ServerException
 
-class UnknownUser(ApoloException):
+
+class UnknownUser(ServerException):
     def __init__(self, access_key: str):
         super().__init__(f"Access key {access_key} does not exist")
 
 
-class UserAlreadyExists(ApoloException):
+class UserAlreadyExists(ServerException):
     def __init__(self, access_key: str):
         super().__init__(f"Access key {access_key} already exists")
 
 
-class InvalidEmail(ApoloException):
+class InvalidEmail(ServerException):
     def __init__(self, email: str):
         super().__init__(f"Email {email} not valid")
 
 
-class WrongCredentials(ApoloException):
+class WrongCredentials(ServerException):
     def __init__(self):
         super().__init__("Username or password invalid")
 
 
-class RoleAlreadyExists(ApoloException):
+class RoleAlreadyExists(ServerException):
     def __init__(self, code: str):
         super().__init__(f"Role with code {code} already exists")
 
 
-class RoleNotFound(ApoloException):
+class RoleNotFound(ServerException):
     def __init__(self, code: str):
         super().__init__(f"Role with code {code} not found")
 
 
-class NotAllowed(ApoloException):
+class NotAllowed(ServerException):
     def __init__(self, access_key: str, action: str, resource: str):
         super().__init__(
             f"User {access_key} not allowed to perform action {action} on "
@@ -88,6 +89,7 @@ def create_user(
         if user:
             raise UserAlreadyExists(access_key)
 
+        # TODO here we should be passing configs to domain layer
         user = model.User(access_key, name, email, password)
         if not user.is_email_valid():
             raise InvalidEmail(email)
@@ -121,6 +123,7 @@ def reset_password(
         user = uow.users.get(access_key)
         if not user:
             raise UnknownUser(access_key)
+        # TODO: this should be inside adapters instead of domain 
         email_html = user.generate_reset_pwd_email(client_url=client_url)
         email_sender.send_email(
             email_to=user.email,

src/auth/utils.py

@@ -1,11 +1,11 @@
 import jwt
 from graphql import GraphQLError
 
-from craftship.auth import config
-from craftship.core.exceptions import ApoloException
+from src.auth import config
+from src.core.exceptions import ServerException
 
 
-class InvalidToken(ApoloException):
+class InvalidToken(ServerException):
     def __init__(self):
         super().__init__("Invalid Token")
 

src/auth/views.py

@@ -1,7 +1,7 @@
 from typing import List, Dict, Optional, Any
 
-from craftship.core.utils import group_rows, create_connection
-from craftship.auth.services import unit_of_work
+from src.core.utils import group_rows, create_connection
+from src.auth.services import unit_of_work
 
 
 def query_role(

src/core/bootstrap.py

@@ -1,7 +1,7 @@
 from typing import Dict
 
-from craftship.core import messagebus, utils
-from craftship.core.ports.unit_of_work import AbstractUnitOfWork
+from src.core import messagebus, utils
+from src.core.ports.unit_of_work import AbstractUnitOfWork
 
 
 def create(

src/core/exceptions.py

@@ -2,16 +2,16 @@
 from graphql import GraphQLError
 
 
-class ApoloException(Exception):
+class ServerException(Exception):
     def __init__(self, msg: str):
         self.message = f"{self.__class__.__name__}: {msg}"
 
 
 def resolve_error(
-    error: Union[Exception, ApoloException], error_resolver: Dict
+    error: Union[Exception, ServerException], error_resolver: Dict
 ) -> GraphQLError:
     message = (
-        error.message if isinstance(error, ApoloException) else str(error)
+        error.message if isinstance(error, ServerException) else str(error)
     )
     status = error_resolver.get(type(error), "UNKNOWN_ERROR")
     return GraphQLError(message, extensions=dict(status=status))

src/core/messagebus.py

@@ -1,8 +1,8 @@
 import logging
 from typing import Any, Callable, Dict, List, Type
 
-from craftship.core.ports import unit_of_work
-from craftship.core.domain import Command, Event, Message
+from src.core.ports import unit_of_work
+from src.core.domain import Command, Event, Message
 
 logger = logging.getLogger("__internal_messagebus__")
 
@@ -12,6 +12,14 @@ class UnknownMessage(Exception):
 
 
 class MessageBus:
+    """A MessageBus has only one responsibility:
+    - Controlling execution flow in service layer
+    It is the practical interface between HTTP and service layer.
+
+    It does that by operating a few tasks:
+    1. Maps events to handlers
+    2. Injects adapters' dependencies in those handlers
+    3. Chains event execution flow by consuming aggregate's event store"""
     def __init__(
         self,
         uow: unit_of_work.AbstractUnitOfWork,
@@ -35,7 +43,6 @@ async def handle_event(self, event: Event) -> None:
                 self.queue.extend(self.uow.collect_new_events())
             except Exception as ex:
                 logger.exception("Exception handling event %s: %s", event, ex)
-                # raise
 
     async def handle_command(self, command: Command) -> None:
         logger.info("Handling command %s", command)

src/core/ports/repository.py

@@ -3,7 +3,7 @@
 
 from sqlalchemy import orm
 
-from craftship.core.domain import Aggregate
+from src.core.domain import Aggregate
 
 
 class AbstractRepository(abc.ABC):

src/core/ports/unit_of_work.py

@@ -3,8 +3,8 @@
 
 from sqlalchemy import create_engine, orm
 
-from apolo import config
-from craftship.core.ports import repository
+from src import config
+from src.core.ports import repository
 
 DEFAULT_SESSION_FACTORY = orm.sessionmaker(
     bind=create_engine(

src/federation.py

@@ -2,29 +2,22 @@
 from typing import Tuple, Optional, Dict
 from sqlalchemy import MetaData
 
-from apolo import orm, config
-import craftship.auth.bootstrap
-import craftship.auth.entrypoint
-import craftship.management.bootstrap
-import craftship.management.entrypoint
-import craftship.management.entrypoint.lambda_worker
+from src import orm, config
+import src.auth.bootstrap
+import src.auth.entrypoint
 
 
-def federation(
+def init(
     start_orm: bool = True, **dependencies
 ) -> Tuple[Optional[MetaData], Dict]:
     """Starts-up as a monothilic service federating all aggregated-services
     Injecting dependencies as expected"""
 
-    lambda_resolver = {
-        "management": craftship.management.entrypoint.lambda_worker.RESOLVER
-    }
+    lambda_resolver = {}
 
-    auth_uow, auth_email_sender = craftship.auth.bootstrap.create(**dependencies)
-    craftship.auth.entrypoint.uow = auth_uow
-    craftship.auth.entrypoint.email_sender = auth_email_sender
-    management_bus = craftship.management.bootstrap.create(**dependencies)
-    craftship.management.entrypoint.messagebus = management_bus
+    auth_uow, auth_email_sender = src.auth.bootstrap.create(**dependencies)
+    src.auth.entrypoint.uow = auth_uow
+    src.auth.entrypoint.email_sender = auth_email_sender
 
     if start_orm:
         metadata = orm.start_mappers()

src/orm.py

@@ -1,6 +1,5 @@
 from sqlalchemy import MetaData
-import craftship.auth.adapters.orm
-import craftship.management.adapters.orm
+import src.auth.adapters.orm
 
 
 def start_mappers() -> MetaData:
@@ -9,7 +8,6 @@ def start_mappers() -> MetaData:
     Classical way
     """
     metadata = MetaData()
-    craftship.auth.adapters.orm.start_mappers(metadata)
-    craftship.management.adapters.orm.start_mappers(metadata)
+    src.auth.adapters.orm.start_mappers(metadata)
 
     return metadata

src/server/app.py

@@ -5,8 +5,8 @@
 from typing import Dict
 from logging import getLogger
 
-from apolo import config
-from craftship.federation import federation
+from src import config
+from src.federation import init 
 
 from tests.fakes import management
 
@@ -21,10 +21,6 @@ def create_app() -> starlette.applications.Starlette:
     origins = [
         "http://localhost:3000",
         "https://localhost:3000",
-        "http://apolo-sandbox.nplbrasil.com.br",
-        "https://apolo-sandbox.nplbrasil.com.br",
-        "http://apolo-staging.nplbrasil.com.br",
-        "https://apolo-staging.nplbrasil.com.br",
     ]
 
     GraphQLApp = create_graphql_asgi_wrapper(debug=False)
@@ -43,15 +39,15 @@ def create_app() -> starlette.applications.Starlette:
 
 
 params: Dict[str, Dict] = {
-    "local": dict(start_orm=True, digesto=management.FakeDigestoService),
-    "sandbox": dict(start_orm=True, digesto=management.FakeDigestoService),
+    "local": dict(start_orm=True,),
+    "sandbox": dict(start_orm=True,),
     "staging": dict(start_orm=True),
     "prod": dict(start_orm=True),
 }
 
 ENVIRONMENT = config.current_environment()
 logger = getLogger(__name__)
-logger.info(f"Apolo Server @ {ENVIRONMENT}")
-federation(**params[ENVIRONMENT])
+logger.info(f"Kingdom Server @ {ENVIRONMENT}")
+init(**params[ENVIRONMENT])
 
 app = create_app()