Merge dev changes (support for Appwrite syncing) (#2)

* wip: agnostic playwright deployment

* build; dockerfile for playwright awcli

* build: for appwrite

* wip: modular automations for appwrite via playwright

* feat: wip appwrite project creation and refactor fix

* feat: fix bug in config storing

* feat: support for syncing projects

* refactor: remove sync func

Author: syntaxsdev

Makefile

@@ -0,0 +1,13 @@
+APPWRITE_CLI_TAG=latest
+APPWRITE_PLAYWRIGHT_TAG=latest
+
+build_appwrite_cli:
+	docker build -t appwrite-cli:$(APPWRITE_CLI_TAG) -f docker/Dockerfile.appwrite_cli ./docker
+
+
+build_appwrite_playwright:
+	docker build -t appwrite-playwright:$(APPWRITE_PLAYWRIGHT_TAG) -f docker/Dockerfile.appwrite_playwright ./docker
+
+# push_appwrite_cli:
+# 	docker tag appwrite-cli:latest appwrite-cli:$(APPWRITE_CLI_TAG)
+# 	docker push appwrite-cli:$(APPWRITE_CLI_TAG)

README.md

@@ -1,15 +1,17 @@
 # appwrite-lab
-Zero-click Appwrite test environments
+Zero-click Appwrite test environments.
+
+Allows you to spin up versioned Appwrite deployments for easy testing via CLI of through code, that can be ran in a sequence of E2E tests.
 
 ## Installation
 ```sh
 pip install appwrite-lab
 ```
-## Appwrite Lab features (coming)
+## Appwrite Lab features (in progress)
 - [x] Spin up ephemeral Appwrite instances with Docker/Podman
 - [x] Automatically grab API keys (for programmatic access)
 - [ ] Test suite
-- [ ] Environment syncing
+- [x] Environment syncing
 - [ ] Appwrite data population
 - [x] Clean teardowns
 
@@ -31,3 +33,14 @@ To teardown,
 ```sh
 appwrite-lab stop test-lab
 ```
+
+### Sync an Appwrite lab from your prod lab schema
+Run in the same folder where your `appwrite.json` is located to sync `all` resources:
+```sh
+appwrite-lab sync test-lab
+```
+or sync a specific resource:
+
+```sh
+appwrite-lab sync test-lab --resource functions
+```

appwrite_lab/_orchestrator.py

@@ -4,20 +4,22 @@
 import json
 import tempfile
 from pathlib import Path
+
+from appwrite_lab.automations.models import BaseVarModel
 from ._state import State
 from dataclasses import dataclass
-from .models import LabService, Automation
+from .models import LabService, Automation, SyncType
 from dotenv import dotenv_values
 from appwrite_lab.utils import console
-from .utils import is_cli
-from .config import PLAYWRIGHT_IMAGE
+from .utils import is_cli, load_config
+from .config import APPWRITE_CLI_IMAGE, APPWRITE_PLAYWRIGHT_IMAGE
 from dataclasses import asdict
 
 
 @dataclass
 class Response:
     message: str
-    data: any
+    data: any = None
     error: bool = False
 
     def __post_init__(self):
@@ -43,7 +45,23 @@ def __init__(self, state: State, backend: str = "auto"):
             Path(__file__).parent / "templates" / "environment" / "dotenv"
         )
 
-    def get_labs(self, collapsed: bool = False):
+    def get_labs(self):
+        """
+        Get all labs.
+        """
+        labs: dict = self.state.get("labs", {})
+        return [LabService(**lab) for lab in labs.values()]
+
+    def get_lab(self, name: str) -> LabService | None:
+        """
+        Get a lab by name.
+        """
+        labs: dict = self.state.get("labs", {})
+        if not (lab := labs.get(name, None)):
+            return None
+        return LabService(**lab)
+
+    def get_formatted_labs(self, collapsed: bool = False):
         """
         Get all labs.
         """
@@ -192,7 +210,6 @@ def deploy_appwrite_lab(
             url = f"http://localhost:{port}"
         else:
             url = ""
-        print("url", url)
         lab = LabService(
             name=name,
             version=version,
@@ -210,7 +227,7 @@ def deploy_appwrite_lab(
                 f"Lab '{name}' deployed, but failed to create API key."
             )
             return api_key_res
-        lab.api_key = api_key_res
+        lab.api_key = api_key_res.data
 
         stored_labs: dict = self.state.get("labs", {}).copy()
         stored_labs[name] = asdict(lab)
@@ -223,7 +240,11 @@ def deploy_appwrite_lab(
         )
 
     def deploy_playwright_automation(
-        self, lab: LabService, automation: str
+        self,
+        lab: LabService,
+        automation: Automation,
+        model: BaseVarModel = None,
+        args: list[str] = [],
     ) -> str | Response:
         """
         Deploy playwright automations on a lab (very few automations supported).
@@ -236,55 +257,69 @@ def deploy_playwright_automation(
         Args:
             lab: The lab to deploy the automations for.
             automation: The automation to deploy.
+            model: The model to use for the automation.
         """
-        if automation == Automation.CREATE_USER_AND_API_KEY:
-            function = (
-                Path(__file__).parent / "playwright" / "functions" / f"{automation}.py"
+        automation = automation.value
+        function = (
+            Path(__file__).parent / "automations" / "functions" / f"{automation}.py"
+        )
+        if not function.exists():
+            return Response(
+                error=True,
+                message=f"Function {automation} not found. This should not happen.",
+                data=None,
             )
-            if not function.exists():
-                return Response(
-                    error=True,
-                    message=f"Function {automation} not found. This should not happen.",
-                    data=None,
+        automation_dir = Path(__file__).parent / "automations"
+        container_work_dir = "/work/automations"
+        env_vars = {
+            "APPWRITE_URL": lab.url,
+            "APPWRITE_PROJECT_ID": lab.project_id,
+            "APPWRITE_ADMIN_EMAIL": lab.admin_email,
+            "APPWRITE_ADMIN_PASSWORD": lab.admin_password,
+            "HOME": container_work_dir,
+            **(model.as_dict_with_prefix("APPWRITE") if model else {}),
+        }
+        envs = " ".join([f"{key}={value}" for key, value in env_vars.items()])
+        docker_env_args = []
+        for key, value in env_vars.items():
+            docker_env_args.extend(["-e", f"{key}={value}"])
+        with tempfile.TemporaryDirectory() as temp_dir:
+            shutil.copytree(automation_dir, temp_dir, dirs_exist_ok=True)
+            function = Path(temp_dir) / "automations" / "functions" / f"{automation}.py"
+
+            cmd = [
+                self.util,
+                "run",
+                "--network",
+                "host",
+                # "--rm",
+                "-u",
+                f"{os.getuid()}:{os.getgid()}",
+                "-v",
+                f"{temp_dir}:{container_work_dir}",
+                *args,
+                *docker_env_args,
+                APPWRITE_PLAYWRIGHT_IMAGE,
+                "python",
+                "-m",
+                f"automations.functions.{automation}",
+            ]
+            cmd_res = self._run_cmd_safely(cmd)
+            if type(cmd_res) is Response and cmd_res.error:
+                cmd_res.message = (
+                    f"Failed to deploy playwright automation {automation}."
                 )
-            env_vars = {
-                "APPWRITE_URL": lab.url,
-                "APPWRITE_PROJECT_ID": lab.project_id,
-                "APPWRITE_ADMIN_EMAIL": lab.admin_email,
-                "APPWRITE_ADMIN_PASSWORD": lab.admin_password,
-            }
-            envs = " ".join([f"{key}={value}" for key, value in env_vars.items()])
-            with tempfile.TemporaryDirectory() as temp_dir:
-                temp_file = Path(temp_dir) / "function.py"
-                shutil.copy(function, temp_file)
-                cmd = [
-                    self.util,
-                    "run",
-                    "--network",
-                    "--rm",
-                    "host",
-                    "-v",
-                    f"{temp_dir}:/playwright",
-                    *[f"-e {key}={value}" for key, value in env_vars.items()],
-                    PLAYWRIGHT_IMAGE,
-                    "bash",
-                    "-c",
-                    f"pip install playwright asyncio && {envs} python /playwright/function.py",
-                ]
-                cmd_res = self._run_cmd_safely(cmd)
-                if type(cmd_res) is Response and cmd_res.error:
-                    cmd_res.message = (
-                        f"Failed to deploy playwright automation {automation}."
+                return cmd_res
+            # If successful, any data should be mounted as result.txt
+            result_file = Path(temp_dir) / "result.txt"
+            if result_file.exists():
+                with open(result_file, "r") as f:
+                    data = f.read()
+                    return Response(
+                        error=False,
+                        message=f"Playwright automation{automation} deployed successfully.",
+                        data=data,
                     )
-                    return cmd_res
-                # If successful, any data should be mounted as result.txt
-                result_file = Path(temp_dir) / "result.txt"
-                if result_file.exists():
-                    with open(result_file, "r") as f:
-                        data = f.read()
-                        return data
-                else:
-                    return None
 
     def teardown_service(self, name: str):
         """
@@ -377,7 +412,7 @@ def run_cmd(cmd: list[str], envs: dict[str, str] | None = None):
         )
         if result.returncode != 0:
             raise OrchestratorError(
-                f"An error occured running a command: {result.stdout}"
+                f"An error occured running a command: {result.stderr}"
             )
         return result
     except Exception as e:

appwrite_lab/automations/__init__.py

@@ -0,0 +1,4 @@
+from .common import AppwriteCLI
+from .utils import PlaywrightAutomationError
+
+__all__ = ("AppwriteCLI", "PlaywrightAutomationError")

appwrite_lab/playwright/automations.py appwrite_lab/automations/automations.pyappwrite_lab/playwright/automations.py renamed to appwrite_lab/automations/automations.py

@@ -0,0 +1,78 @@
+from .utils import run_cmd, env_dict_to_str
+from dataclasses import dataclass
+
+
+@dataclass
+class CommandExecutor:
+    cmd: list[str]
+    envs: dict[str, str] | None = None
+
+    def run(self):
+        return run_cmd(self.cmd, self.envs)
+
+    def __call__(self):
+        return self.run()
+
+
+class AppwriteCLI:
+    def login(self, url: str, email: str, password: str) -> CommandExecutor:
+        """
+        Login to Appwrite.
+
+        Args:
+            url: The URL of the Appwrite instance.
+            email: The email of the user.
+            password: The password of the user.
+
+        Returns:
+            bool: True if login was successful, False otherwise.
+        """
+        cmd = [
+            "appwrite",
+            "login",
+            "--endpoint",
+            url,
+            "--email",
+            email,
+            "--password",
+            password,
+        ]
+        return CommandExecutor(cmd, None)
+
+    def get_project(self, project_id: str) -> CommandExecutor:
+        """
+        Get a project from Appwrite.
+
+        Args:
+            project_id: The ID of the project.
+        """
+        cmd = ["appwrite", "projects", "get", "--project-id", project_id]
+        return CommandExecutor(cmd)
+
+    def sync_project(self, resource: str) -> CommandExecutor:
+        """
+        Sync a project from Appwrite.
+        """
+        cmd = ["bash", "-c", f"yes YES | appwrite push {resource}"]
+        return CommandExecutor(cmd)
+
+
+def execute_same_shell(*execs: CommandExecutor) -> list[str]:
+    """
+    Run a batch of commands in the same shell and return the outputs.
+
+    Args:
+        execs: The commands to run.
+    """
+    all_cmds = []
+    for exc in execs:
+        cmds = exc.cmd.copy()
+        if exc.envs:
+            # Prepend environment variables to the command
+            env_str = env_dict_to_str(exc.envs)
+            cmds.insert(0, env_str)
+        all_cmds.append(" ".join(cmds))
+
+    # Join all commands with && to run in same shell
+    combined_cmd = " && ".join(all_cmds)
+    return run_cmd(["bash", "-c", combined_cmd])