restiny 0.5.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

restiny/__about__.py

@@ -1 +1 @@
-__version__ = '0.5.0'
+__version__ = '0.6.1'

restiny/__main__.py

@@ -15,6 +15,7 @@ def run_app() -> None:
     from restiny.consts import CONF_DIR, DB_FILE
     from restiny.data.db import DBManager
     from restiny.data.repos import (
+        EnvironmentsSQLRepo,
         FoldersSQLRepo,
         RequestsSQLRepo,
         SettingsSQLRepo,
@@ -29,6 +30,7 @@ def run_app() -> None:
         folders_repo=FoldersSQLRepo(db_manager=db_manager),
         requests_repo=RequestsSQLRepo(db_manager=db_manager),
         settings_repo=SettingsSQLRepo(db_manager=db_manager),
+        environments_repo=EnvironmentsSQLRepo(db_manager=db_manager),
     ).run()
 
 

restiny/assets/style.tcss

@@ -71,6 +71,10 @@ Input {
     padding: 0;
 }
 
+.p-1 {
+    padding: 1;
+}
+
 .pt-1 {
     padding-top: 1;
 }
@@ -92,10 +96,14 @@ Input {
     padding-right: 1;
 }
 
-.m {
+.m-0 {
     margin: 0;
 }
 
+.m-1 {
+    margin: 1;
+}
+
 .mt-1 {
     margin-top: 1;
 }

restiny/data/models.py

@@ -12,7 +12,7 @@ class SQLFolder(SQLModelBase):
     __tablename__ = 'folders'
 
     id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
-    name: Mapped[str] = mapped_column()
+    name: Mapped[str] = mapped_column(nullable=False)
     parent_id: Mapped[int | None] = mapped_column(
         ForeignKey('folders.id'), nullable=True
     )
@@ -38,24 +38,24 @@ class SQLRequest(SQLModelBase):
     folder_id: Mapped[int] = mapped_column(
         ForeignKey('folders.id'), nullable=False
     )
-    name: Mapped[str] = mapped_column()
+    name: Mapped[str] = mapped_column(nullable=False)
 
-    method: Mapped[str] = mapped_column()
-    url: Mapped[str | None] = mapped_column()
-    headers: Mapped[str | None] = mapped_column()
-    params: Mapped[str | None] = mapped_column()
+    method: Mapped[str] = mapped_column(nullable=False)
+    url: Mapped[str | None] = mapped_column(nullable=True)
+    headers: Mapped[str | None] = mapped_column(nullable=True)
+    params: Mapped[str | None] = mapped_column(nullable=True)
 
-    body_enabled: Mapped[bool] = mapped_column()
-    body_mode: Mapped[str] = mapped_column()
-    body: Mapped[str | None] = mapped_column()
+    body_enabled: Mapped[bool] = mapped_column(nullable=False)
+    body_mode: Mapped[str] = mapped_column(nullable=False)
+    body: Mapped[str | None] = mapped_column(nullable=True)
 
-    auth_enabled: Mapped[bool] = mapped_column()
-    auth_mode: Mapped[str] = mapped_column()
-    auth: Mapped[str | None] = mapped_column()
+    auth_enabled: Mapped[bool] = mapped_column(nullable=False)
+    auth_mode: Mapped[str] = mapped_column(nullable=False)
+    auth: Mapped[str | None] = mapped_column(nullable=True)
 
-    option_timeout: Mapped[float | None] = mapped_column()
-    option_follow_redirects: Mapped[bool] = mapped_column()
-    option_verify_ssl: Mapped[bool] = mapped_column()
+    option_timeout: Mapped[float | None] = mapped_column(nullable=True)
+    option_follow_redirects: Mapped[bool] = mapped_column(nullable=False)
+    option_verify_ssl: Mapped[bool] = mapped_column(nullable=False)
 
     created_at: Mapped[datetime] = mapped_column(
         DateTime(),
@@ -88,3 +88,24 @@ class SQLSettings(SQLModelBase):
         onupdate=func.current_timestamp(),
         nullable=False,
     )
+
+
+class SQLEnvironment(SQLModelBase):
+    __tablename__ = 'environments'
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+
+    name: Mapped[str] = mapped_column(nullable=False, unique=True)
+    variables: Mapped[str] = mapped_column(nullable=False)
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(),
+        default=func.current_timestamp(),
+        nullable=False,
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(),
+        default=func.current_timestamp(),
+        onupdate=func.current_timestamp(),
+        nullable=False,
+    )

restiny/data/repos.py

@@ -8,12 +8,17 @@ from enum import StrEnum
 from functools import wraps
 from typing import Any
 
-from sqlalchemy import select
+from sqlalchemy import case, select
 from sqlalchemy.exc import IntegrityError, InterfaceError, OperationalError
 
 from restiny.data.db import DBManager
-from restiny.data.models import SQLFolder, SQLRequest, SQLSettings
-from restiny.entities import Folder, Request, Settings
+from restiny.data.models import (
+    SQLEnvironment,
+    SQLFolder,
+    SQLRequest,
+    SQLSettings,
+)
+from restiny.entities import Environment, Folder, Request, Settings
 
 
 def safe_repo(func):
@@ -349,3 +354,102 @@ class SettingsSQLRepo(SQLRepoBase):
             created_at=settings.created_at,
             updated_at=settings.updated_at,
         )
+
+
+class EnvironmentsSQLRepo(SQLRepoBase):
+    @safe_repo
+    def get_by_id(self, id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_environment = session.get(SQLEnvironment, id)
+
+            if not sql_environment:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            environment = self._sql_to_environment(sql_environment)
+            return RepoResp(data=environment)
+
+    @safe_repo
+    def get_by_name(self, name: str) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_environment = session.scalar(
+                select(SQLEnvironment).where(SQLEnvironment.name == name)
+            )
+
+            if not sql_environment:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            environment = self._sql_to_environment(sql_environment)
+            return RepoResp(data=environment)
+
+    @safe_repo
+    def list(self) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_envs = session.scalars(
+                select(SQLEnvironment).order_by(
+                    case((SQLEnvironment.name == 'global', 0), else_=1),
+                    SQLEnvironment.name.asc(),
+                )
+            )
+            envs = [self._sql_to_environment(sql_env) for sql_env in sql_envs]
+            return RepoResp(data=envs)
+
+    @safe_repo
+    def create(self, environment: Environment) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_env = self._environment_to_sql(environment)
+            session.add(sql_env)
+            session.flush()
+            new_env = self._sql_to_environment(sql_env)
+            return RepoResp(data=new_env)
+
+    @safe_repo
+    def update(self, environment: Environment) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_environment = session.get(SQLEnvironment, environment.id)
+            if not sql_environment:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            new_data = self._environment_to_sql(environment)
+            for field in self._updatable_sql_fields:
+                setattr(sql_environment, field, getattr(new_data, field))
+
+            session.flush()
+
+            new_environment = self._sql_to_environment(sql_environment)
+            return RepoResp(data=new_environment)
+
+    @safe_repo
+    def delete_by_id(self, id: int) -> RepoResp:
+        with self.db_manager.session_scope() as session:
+            sql_environment = session.get(SQLEnvironment, id)
+            if not sql_environment:
+                return RepoResp(status=RepoStatus.NOT_FOUND)
+
+            session.delete(sql_environment)
+            return RepoResp()
+
+    @property
+    def _updatable_sql_fields(self) -> list[str]:
+        return [SQLEnvironment.name.key, SQLEnvironment.variables.key]
+
+    def _sql_to_environment(
+        self, sql_environment: SQLEnvironment
+    ) -> Environment:
+        return Environment(
+            id=sql_environment.id,
+            name=sql_environment.name,
+            variables=json.loads(sql_environment.variables),
+            created_at=sql_environment.created_at.replace(tzinfo=UTC),
+            updated_at=sql_environment.updated_at.replace(tzinfo=UTC),
+        )
+
+    def _environment_to_sql(self, environment: Environment) -> SQLEnvironment:
+        return SQLEnvironment(
+            id=environment.id,
+            name=environment.name,
+            variables=json.dumps(
+                [variable.model_dump() for variable in environment.variables]
+            ),
+            created_at=environment.created_at,
+            updated_at=environment.updated_at,
+        )

restiny/entities.py

@@ -124,6 +124,109 @@ class Request(BaseModel):
     created_at: datetime | None = None
     updated_at: datetime | None = None
 
+    def resolve_variables(
+        self, variables: list[Environment.Variable]
+    ) -> 'Request':
+        def _resolve_variables(value: str) -> str:
+            new_value = value
+            for variable in variables:
+                if not variable.enabled:
+                    continue
+
+                new_value = new_value.replace(
+                    '{{' + variable.key + '}}', variable.value
+                )
+                new_value = new_value.replace(
+                    '${' + variable.key + '}', variable.value
+                )
+            return new_value
+
+        resolved_url = _resolve_variables(self.url)
+
+        resolved_headers = [
+            self.Header(
+                enabled=header.enabled,
+                key=_resolve_variables(header.key),
+                value=_resolve_variables(header.value),
+            )
+            for header in self.headers
+        ]
+
+        resolved_params = [
+            self.Param(
+                enabled=param.enabled,
+                key=_resolve_variables(param.key),
+                value=_resolve_variables(param.value),
+            )
+            for param in self.params
+        ]
+
+        resolved_auth = self.auth
+        if self.auth_enabled:
+            if self.auth_mode == AuthMode.BASIC:
+                resolved_auth = self.BasicAuth(
+                    username=_resolve_variables(self.auth.username),
+                    password=_resolve_variables(self.auth.password),
+                )
+            elif self.auth_mode == AuthMode.BEARER:
+                resolved_auth = self.BearerAuth(
+                    token=_resolve_variables(self.auth.token)
+                )
+            elif self.auth_mode == AuthMode.API_KEY:
+                resolved_auth = self.ApiKeyAuth(
+                    key=_resolve_variables(self.auth.key),
+                    value=_resolve_variables(self.auth.value),
+                    where=self.auth.where,
+                )
+            elif self.auth_mode == AuthMode.DIGEST:
+                resolved_auth = self.DigestAuth(
+                    username=_resolve_variables(self.auth.username),
+                    password=_resolve_variables(self.auth.password),
+                )
+
+        resolved_body = self.body
+        if self.body_enabled:
+            if self.body_mode == BodyMode.RAW:
+                resolved_body = self.RawBody(
+                    language=self.body.language,
+                    value=_resolve_variables(self.body.value),
+                )
+            elif self.body_mode == BodyMode.FILE:
+                pass
+            elif self.body_mode == BodyMode.FORM_URLENCODED:
+                resolved_body = self.UrlEncodedFormBody(
+                    fields=[
+                        self.UrlEncodedFormBody.Field(
+                            enabled=field.enabled,
+                            key=_resolve_variables(field.key),
+                            value=_resolve_variables(field.value),
+                        )
+                        for field in self.body.fields
+                    ]
+                )
+            elif self.body_mode == BodyMode.FORM_MULTIPART:
+                resolved_body = self.MultipartFormBody(
+                    fields=[
+                        self.MultipartFormBody.Field(
+                            value_kind=field.value_kind,
+                            enabled=field.enabled,
+                            key=_resolve_variables(field.key),
+                            value=_resolve_variables(field.value),
+                        )
+                        for field in self.body.fields
+                    ]
+                )
+
+        return self.model_copy(
+            update=dict(
+                url=resolved_url,
+                headers=resolved_headers,
+                params=resolved_params,
+                body=resolved_body,
+                auth=resolved_auth,
+            )
+        )
+
     def to_httpx_req(self) -> httpx.Request:
         headers: dict[str, str] = {
             header.key: header.value
@@ -260,7 +363,7 @@ class Request(BaseModel):
         body_files = None
         if self.body_enabled:
             if self.body_mode == BodyMode.RAW:
-                body_raw = self.body
+                body_raw = self.body.value
             elif self.body_mode == BodyMode.FORM_URLENCODED:
                 body_form_urlencoded = {
                     form_field.key: form_field.value
@@ -318,3 +421,18 @@ class Settings(BaseModel):
 
     created_at: datetime | None = None
     updated_at: datetime | None = None
+
+
+class Environment(BaseModel):
+    class Variable(BaseModel):
+        enabled: bool
+        key: str
+        value: str
+
+    id: int | None = None
+
+    name: str
+    variables: list[Variable] = _Field(default_factory=list)
+
+    created_at: datetime | None = None
+    updated_at: datetime | None = None

restiny/ui/__init__.py

@@ -5,6 +5,7 @@ This module contains the specific sections of the DataFox user interface (UI).
 from restiny.ui.collections_area import CollectionsArea
 from restiny.ui.request_area import RequestArea
 from restiny.ui.response_area import ResponseArea
+from restiny.ui.top_bar_area import TopBarArea
 from restiny.ui.url_area import URLArea
 
 __all__ = [
@@ -12,4 +13,5 @@ __all__ = [
     'ResponseArea',
     'URLArea',
     'CollectionsArea',
+    'TopBarArea',
 ]