ts-backend-check 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

ts_backend_check/__init__.py

@@ -1,7 +1,5 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
-__version__ = "1.0.0"
+from ts_backend_check.checker import TypeChecker
+from ts_backend_check.cli.main import main
 
-from .checker import TypeChecker
-from .cli import cli
-
-__all__ = ["cli", "TypeChecker"]
+__all__ = ["main", "TypeChecker"]

ts_backend_check/checker.py

@@ -5,9 +5,9 @@ Main module for checking Django models against TypeScript types.
 
 from typing import Dict, List, Set
 
-from .django_parser import extract_model_fields
-from .typescript_parser import TypeScriptParser
-from .utils import snake_to_camel
+from ts_backend_check.parsers.django_parser import extract_model_fields
+from ts_backend_check.parsers.typescript_parser import TypeScriptParser
+from ts_backend_check.utils import snake_to_camel
 
 
 class TypeChecker:
@@ -149,8 +149,8 @@ class TypeChecker:
         """
         potential_names = TypeChecker._generate_potential_names(model_name)
         return (
-            f"\nNo matching TypeScript interface found for model: {model_name}\n"
-            f"Searched for interfaces: {', '.join(potential_names)}"
+            f"\nNo matching TypeScript interface found for model: {model_name}"
+            f"\nSearched for interfaces: {', '.join(potential_names)}"
         )
 
     @staticmethod
@@ -178,8 +178,8 @@ class TypeChecker:
         """
         camel_field = snake_to_camel(input_str=field)
         return (
-            f"\nField '{field}' (camelCase: '{camel_field}') from model '{model_name}' "
-            f"is missing in TypeScript types.\n"
-            f"Expected to find in interface(s): {', '.join(interfaces.keys())}\n"
-            f"To ignore this field, add a comment that references it like: '// Note: {camel_field} is backend only'"
+            f"\nField '{field}' (camelCase: '{camel_field}') from model '{model_name}' is missing in TypeScript types."
+            f"\nExpected to find in interface(s): {', '.join(interfaces.keys())}"
+            f"\nTo ignore this field, add a comment that references it like: '// Note: {camel_field} is backend only'"
+            "\n"
         )

ts_backend_check/cli/__init__.py

@@ -1,8 +1,4 @@
 # SPDX-License-Identifier: AGPL-3.0-or-later
-"""
-CLI package for ts-backend-check.
-"""
+from ts_backend_check.cli.main import main
 
-from .main import cli
-
-__all__ = ["cli"]
+__all__ = ["main"]

ts_backend_check/cli/check_blank.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Functionality to check TypeScript interfaces for fields that should be optional based on Django models.
+"""
+
+import ast
+from pathlib import Path
+from typing import Dict, Set
+
+from rich.console import Console
+
+from ts_backend_check.parsers.django_parser import DjangoModelVisitor
+
+ROOT_DIR = Path.cwd()
+console = Console()
+
+
+class BlankParser(DjangoModelVisitor):
+    """
+    AST visitor to extract blank fields from Django models based on DjangoModelVisitor.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.blank_models: Dict[str, Set[str]] = {}
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """
+        Check assignment statements within a class which accepts blank fields.
+
+        Parameters
+        ----------
+        node : ast.Assign
+            An assignment definition from Python AST (Abstract Syntax Tree).
+            It represents an assignment statement (e.g., x = 42).
+        """
+        if not self.current_model:
+            return
+
+        for target in node.targets:
+            if (
+                (
+                    isinstance(target, ast.Name)
+                    and not target.id.startswith("_")
+                    and isinstance(node.value, ast.Call)
+                    and hasattr(node.value.func, "attr")
+                )
+                and any(
+                    field_type in node.value.func.attr
+                    for field_type in self.DJANGO_FIELD_TYPES
+                )
+                and any(
+                    kw.arg == "blank"
+                    and isinstance(kw.value, ast.Constant)
+                    and kw.value.value is True
+                    for kw in node.value.keywords
+                )
+            ):
+                if self.current_model not in self.blank_models:
+                    self.blank_models[self.current_model] = set()
+
+                self.blank_models[self.current_model].add(target.id)
+
+
+def check_blank(file_path: str) -> Dict[str, Set[str]]:
+    """
+    Function to extract fields from Django models file which accepts blank values.
+
+    Parameters
+    ----------
+    file_path : str
+        A models.py file that defines Django models.
+
+    Returns
+    -------
+    Dict[str, Set[str]]
+        The fields from the models file extracted into a dictionary for future processing.
+    """
+    model_path = ROOT_DIR / file_path
+
+    if model_path.is_file():
+        with open(model_path, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+            # Skip any empty lines at the beginning.
+            while content.startswith("\n"):
+                content = content[1:]
+
+        try:
+            tree = ast.parse(content)
+
+        except SyntaxError as e:
+            raise SyntaxError(
+                f"Failed to parse {model_path}. Make sure it's a valid Python file. Error: {str(e)}"
+            ) from e
+
+        parser = BlankParser()
+        parser.visit(tree)
+
+        if len(parser.blank_models) == 0:
+            console.print("[green]No models have any blank fields specified.[green]")
+
+        else:
+            for k, v in parser.blank_models.items():
+                console.print(
+                    f"[yellow]Model {k} has fields {sorted(v)} set as optional."
+                )
+
+    else:
+        print("Check the path entered.")
+
+    return parser.blank_models

ts_backend_check/cli/config.py

@@ -0,0 +1,164 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Configure cli to run based on a YAML configuration file.
+"""
+
+from pathlib import Path
+
+from yaml import dump
+
+YAML_CONFIG_FILE_PATH = (
+    Path(__file__).parent.parent.parent.parent / ".ts-backend-check.yaml"
+)
+
+PROJECT_ROOT_PATH = Path(__file__).parent.parent.parent.parent
+
+
+def configure_paths() -> None:
+    """
+    Function to receive paths from user.
+    """
+    config_options = {}
+    while True:
+        print("\n--- Adding new model/interface configuration ---")
+
+        key = input(
+            "Enter the model-interface type (eg: 'auth', 'orgs', 'groups'): "
+        ).strip()
+        if not key:
+            print("Key cannot be empty. Please try again.")
+            continue
+
+        # Get backend path.
+        while True:
+            backend_path = input("Enter the path for Django models.py file: ").strip()
+            if not backend_path:
+                print("Path cannot be empty.")
+                continue
+
+            if path_exists(backend_path):
+                break
+
+            print(f"File not found: {PROJECT_ROOT_PATH / backend_path}")
+            print("Please check the path and try again.")
+
+        # Get frontend path.
+        while True:
+            frontend_path = input("Enter path to TypeScript interface file: ").strip()
+            if not frontend_path:
+                print("Path cannot be empty. Please try again.")
+                continue
+
+            if path_exists(frontend_path):
+                break
+
+            print(f"File not found: {PROJECT_ROOT_PATH / frontend_path}")
+            print("Please check the path and try again.")
+
+        config_options[key] = {
+            "backend_model_path": backend_path,
+            "frontend_interface_path": frontend_path,
+        }
+
+        print(f"✓ Added configuration for '{key}'")
+
+        continue_config = input(
+            "Do you wish to add another model/interface configuration? (y/[n])"
+        ).strip()
+
+        if continue_config.lower() in ["n", ""]:
+            if config_options:
+                write_config(config_options)
+                print(
+                    f"\n✓ Configuration complete! Added {len(config_options)} configuration(s)."
+                )
+            break
+
+        if config_options:
+            write_config(config_options)
+            print(
+                f"\n✓ Configuration complete! Added {len(config_options)} configuration(s)."
+            )
+
+        else:
+            print("\nNo configurations added.")
+
+
+def path_exists(path: str) -> bool:
+    """
+    Check if path entered by the user exists withing the filesystem.
+
+    Parameters
+    ----------
+    path : str
+        Path should be entered as a string from the user.
+
+    Returns
+    -------
+    bool
+        Return true or false based on if path exists.
+    """
+    full_path = Path(__file__).parent.parent.parent.parent / path
+    if Path(full_path).is_file():
+        return True
+
+    return False
+
+
+def write_config(config: dict[str, dict[str, str]]) -> None:
+    """
+    Function to write into .ts-backend-check.yaml file.
+
+    Parameters
+    ----------
+    config : dict[str, dict[str, str]]
+        Passing a dictionary as key str with another dict as value.
+    """
+    try:
+        options = f"""# Configuration file for ts-backend-check validation.
+# See https://github.com/activist-org/ts-backend-check for details.
+
+# Paths:
+{dump(config)}
+
+"""
+        with open(YAML_CONFIG_FILE_PATH, "w") as file:
+            file.write(options)
+
+    except IOError as e:
+        print(f"Error while writing config file: {e}")
+
+
+def create_config() -> None:
+    """
+    Main function to create or update configuration.
+    """
+    print("ts-backend-check Configuration Setup")
+    print("=" * 40)
+
+    if YAML_CONFIG_FILE_PATH.is_file():
+        reconfig_choice = input(
+            "Configuration file exists. Do you want to re-configure your .ts-backend-check.yaml file? (y/[n]) "
+        )
+        if reconfig_choice.lower() in ["n", ""]:
+            print("Exiting without changes.")
+            return
+
+        print("Reconfiguring...")
+
+    else:
+        print("Creating new configuration file...")
+
+    try:
+        configure_paths()
+
+    except KeyboardInterrupt:
+        print("\n\nConfiguration cancelled by user.")
+
+    except Exception as e:
+        print(f"\nError during configuration: {e}")
+        print("Configuration cancelled.")
+
+
+if __name__ == "__main__":
+    create_config()

ts_backend_check/cli/main.py

@@ -3,56 +3,144 @@
 Setup and commands for the ts-backend-check command line interface.
 """
 
+import argparse
 import sys
+from argparse import ArgumentParser
+from pathlib import Path
 
-import click
+from rich import print as rprint
+from rich.text import Text
 
-from ..checker import TypeChecker
+from ts_backend_check.checker import TypeChecker
+from ts_backend_check.cli.check_blank import check_blank
+from ts_backend_check.cli.config import create_config
+from ts_backend_check.cli.upgrade import upgrade_cli
+from ts_backend_check.cli.version import get_version_message
 
+ROOT_DIR = Path.cwd()
 
-@click.group()
-@click.version_option()
-def cli():
-    """
-    TS Backend Check is a Python package used to check TypeScript types against their corresponding backend models.
+
+def main() -> None:
     """
-    pass
+    The main check function to compare a the methods within a backend model to a corresponding TypeScript file.
 
+    Notes
+    -----
+    The available command line arguments are:
+    - --backend-model-file (-bmf): Path to the backend model file (e.g. Python class)
+    - --typescript-file (-tsf): Path to the TypeScript interface/type file
 
-@cli.command()
-@click.argument("backend_model", type=click.Path(exists=True))
-@click.argument("typescript_file", type=click.Path(exists=True))
-def check(backend_model: str, typescript_file: str):
+    Examples
+    --------
+    >>> ts-backend-check -bmf <backend-model-file> -tsf <typescript-file>
     """
-    Check TypeScript types against backend models.
+    # MARK: CLI Base
 
-    This command checks if all fields from the backend model are properly represented
-    in the TypeScript types file. It supports marking fields as backend-only using
-    special comments in the TypeScript file.
+    parser = ArgumentParser(
+        prog="ts-backend-check",
+        description="Checks the types in TypeScript files against the corresponding backend models.",
+        epilog="Visit the codebase at https://github.com/activist-org/ts-backend-check to learn more!",
+        formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=60),
+    )
 
-    Parameters
-    ----------
-    backend_model : str
-        The path to the backend model file (e.g. Python class).
+    parser._actions[0].help = "Show this help message and exit."
 
-    typescript_file : str
-        The path to the TypeScript interface/type file.
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"{get_version_message()}",
+        help="Show the version of the ts-backend-check CLI.",
+    )
 
-    Examples
-    --------
-    ts-backend-check check src/models/user.py src/types/user.ts
-    """
-    checker = TypeChecker(models_file=backend_model, types_file=typescript_file)
-    if missing := checker.check():
-        click.echo("Missing TypeScript fields found:")
-        click.echo("\n".join(missing))
-        click.echo(
-            f"\nPlease correct the {len(missing)} fields above to have backend models and frontend types fully synced."
+    parser.add_argument(
+        "-u",
+        "--upgrade",
+        action="store_true",
+        help="Upgrade the ts-backend-check CLI to the latest version.",
+    )
+
+    parser.add_argument(
+        "-bmf",
+        "--backend-model-file",
+        help="Path to the backend model file (e.g. Python class).",
+    )
+
+    parser.add_argument(
+        "-tsf",
+        "--typescript-file",
+        help="Path to the TypeScript interface/type file.",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--configure",
+        action="store_true",
+        help="Configure a YAML file to simplify your checks.",
+    )
+
+    parser.add_argument(
+        "-cb",
+        "--check-blank",
+        help="Check for fields marked blank=True within Django models.",
+    )
+
+    # MARK: Setup CLI
+
+    args = parser.parse_args(args=None if sys.argv[1:] else ["--help"])
+
+    if args.upgrade:
+        upgrade_cli()
+        return
+
+    if args.configure:
+        create_config()
+        return
+
+    if args.check_blank:
+        check_blank(args.check_blank)
+        return
+
+    # MARK: Run Check
+
+    backend_model_file_path = ROOT_DIR / args.backend_model_file
+    ts_file_path = ROOT_DIR / args.typescript_file
+
+    if not backend_model_file_path.is_file():
+        rprint(
+            f"[red]{args.backend_model_file} that should contain the backend models does not exist. Please check and try again.[/red]"
+        )
+
+    elif not ts_file_path.is_file():
+        rprint(
+            f"[red]{args.typescript_file} file that should contain the TypeScript types does not exist. Please check and try again.[/red]"
         )
-        sys.exit(1)
 
-    click.echo("All model fields are properly typed in TypeScript!")
+    else:
+        checker = TypeChecker(
+            models_file=args.backend_model_file,
+            types_file=args.typescript_file,
+        )
+
+        if missing := checker.check():
+            rprint(
+                "\n[red]❌ ts-backend-check error: Missing typescript fields found:[/red]\n"
+            )
+
+            # Print each error message in red.
+            for msg in missing:
+                rprint(Text.from_markup(f"[red]{msg}[/red]"))
+
+            field_or_fields = "fields" if len(missing) > 1 else "field"
+            rprint(
+                f"\n[red]Please fix the {len(missing)} {field_or_fields} above to have the backend models synced with the typescript interfaces.[/red]"
+            )
+            sys.exit(1)
+
+        rprint(
+            "[green]✅ Success: All models are synced with their corresponding TypeScript interfaces.[/green]"
+        )
 
 
 if __name__ == "__main__":
-    cli()
+    main()

ts_backend_check/cli/upgrade.py

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Functions to update the ts-backend-check CLI based on install method.
+"""
+
+import subprocess
+import sys
+
+from packaging import version
+from packaging.version import InvalidVersion
+
+from ts_backend_check.cli.version import (
+    UNKNOWN_VERSION_NOT_FETCHED,
+    get_latest_version,
+    get_local_version,
+)
+
+
+def upgrade_cli() -> None:
+    """
+    Upgrade the CLI tool to the latest available version on PyPI.
+
+    Raises
+    ------
+    subprocess.CalledProcessError
+        If the installation of the latest version fails.
+    """
+    local_version = get_local_version()
+    latest_version_message = get_latest_version()
+
+    if latest_version_message == UNKNOWN_VERSION_NOT_FETCHED:
+        print(
+            "Unable to fetch the latest version from GitHub. Please check the GitHub repository or your internet connection."
+        )
+        return
+
+    latest_version = latest_version_message.split("v")[-1]
+    local_version_clean = local_version.strip()
+    latest_version_clean = latest_version.replace("ts-backend-check", "").strip()
+
+    # Handle empty or invalid version strings.
+    try:
+        local_ver = (
+            version.parse(local_version_clean)
+            if local_version_clean
+            else version.parse("0.0.0")
+        )
+
+    except InvalidVersion:
+        # If local version is invalid, treat it as 0.0.0 to force upgrade.
+        local_ver = version.parse("0.0.0")
+
+    try:
+        latest_ver = version.parse(latest_version_clean)
+
+    except InvalidVersion:
+        print("Unable to parse the latest version. Please check the GitHub repository.")
+        return
+
+    if local_ver == latest_ver:
+        print("You already have the latest version of ts-backend-check.")
+
+    elif local_ver > latest_ver:
+        print(
+            f"ts-backend-check v{local_version_clean} is higher than the currently released version ts-backend-check v{latest_version_clean}. Hopefully this is a development build, and if so, thanks for your work on ts-backend-check! If not, please report this to the team at https://github.com/activist-org/ts-backend-check/issues."
+        )
+
+    else:
+        print(f"Current version: {local_version}")
+        print(f"Latest version: {latest_version}")
+        print("Updating ts-backend-check with pip...")
+        try:
+            subprocess.check_call(
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "--upgrade",
+                    "ts-backend-check",
+                ]
+            )
+
+        except subprocess.CalledProcessError as e:
+            print(
+                f"Failed to install the latest version of ts-backend-check with error {e}. Please check the error message and report any issues to the team at https://github.com/activist-org/ts-backend-check/issues."
+            )
+
+
+if __name__ == "__main__":
+    upgrade_cli()

ts_backend_check/cli/version.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Functions for checking current version of the ts-backend-check CLI.
+"""
+
+import importlib.metadata
+from typing import Any, Dict
+
+import requests
+
+UNKNOWN_VERSION = "Unknown ts-backend-check version"
+UNKNOWN_VERSION_NOT_PIP = f"{UNKNOWN_VERSION} (Not installed via pip)"
+UNKNOWN_VERSION_NOT_FETCHED = f"{UNKNOWN_VERSION} (Unable to fetch version)"
+
+
+def get_local_version() -> str:
+    """
+    Get the local version of the ts-backend-check package.
+
+    Returns
+    -------
+    str
+        The version of the installed ts-backend-check package, or a message indicating
+        that the package is not installed via pip.
+    """
+    try:
+        return importlib.metadata.version("ts-backend-check")
+
+    except importlib.metadata.PackageNotFoundError:
+        return UNKNOWN_VERSION_NOT_PIP
+
+
+def get_latest_version() -> Any:
+    """
+    Get the latest version of the ts-backend-check package from GitHub.
+
+    Returns
+    -------
+    Any
+        The latest version of the ts-backend-check package, or a message indicating
+        that the version could not be fetched.
+    """
+    try:
+        response = requests.get(
+            "https://api.github.com/repos/activist-org/ts-backend-check/releases/latest"
+        )
+        response_data: Dict[str, Any] = response.json()
+        return response_data["name"]
+
+    except Exception:
+        return UNKNOWN_VERSION_NOT_FETCHED
+
+
+def get_version_message() -> str:
+    """
+    Get a message indicating the local and latest versions of the ts-backend-check package.
+
+    Returns
+    -------
+    str
+        A message indicating the local version, the latest version, and whether
+        an upgrade is available.
+    """
+    local_version = get_local_version()
+    latest_version = get_latest_version()
+
+    if local_version == UNKNOWN_VERSION_NOT_PIP:
+        return UNKNOWN_VERSION_NOT_PIP
+
+    elif latest_version == UNKNOWN_VERSION_NOT_FETCHED:
+        return UNKNOWN_VERSION_NOT_FETCHED
+
+    local_version_clean = local_version.strip()
+    latest_version_clean = latest_version.replace("ts-backend-check", "").strip()
+
+    if local_version_clean == latest_version_clean:
+        return f"ts-backend-check v{local_version_clean}"
+
+    elif local_version_clean > latest_version_clean:
+        return f"ts-backend-check v{local_version_clean} is higher than the currently released version ts-backend-check v{latest_version_clean}. Hopefully this is a development build, and if so, thanks for your work on ts-backend-check! If not, please report this to the team at https://github.com/activist-org/ts-backend-check/issues."
+
+    else:
+        return f"ts-backend-check v{local_version_clean} (Upgrade available: ts-backend-check v{latest_version_clean}). To upgrade: ts-backend-check -u"
+
+
+if __name__ == "__main__":
+    print(get_version_message())

ts_backend_check/parsers/django_parser.py

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Module for parsing Django models and extracting field information.
+"""
+
+import ast
+from typing import Dict, Set
+
+
+class DjangoModelVisitor(ast.NodeVisitor):
+    """
+    AST visitor to extract fields from Django models.
+    """
+
+    DJANGO_FIELD_TYPES = {
+        "Field",
+        "CharField",
+        "TextField",
+        "IntegerField",
+        "BooleanField",
+        "DateTimeField",
+        "ForeignKey",
+        "ManyToManyField",
+        "OneToOneField",
+        "EmailField",
+        "URLField",
+        "FileField",
+        "ImageField",
+        "DecimalField",
+        "AutoField",
+    }
+
+    def __init__(self) -> None:
+        self.models: Dict[str, Set[str]] = {}
+        self.current_model: str | None = None
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """
+        Check class definitions, specifically those that inherit from other classes.
+
+        Parameters
+        ----------
+        node : ast.ClassDef
+            A class definition from Python AST (Abstract Syntax Tree).
+            It contains information about the class, such as its name, base classes, body, decorators, etc.
+        """
+        # Only process classes that inherit from something.
+        if node.bases:
+            self.current_model = node.name
+            if self.current_model not in self.models:
+                self.models[self.current_model] = set()
+
+            self.generic_visit(node)
+
+        self.current_model = None
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """
+        Check assignment statements within a class.
+
+        Parameters
+        ----------
+        node : ast.Assign
+            An assignment definition from Python AST (Abstract Syntax Tree).
+            It represents an assignment statement (e.g., x = 42).
+        """
+        if not self.current_model:
+            return
+
+        for target in node.targets:
+            if (
+                isinstance(target, ast.Name)
+                and not target.id.startswith("_")
+                and isinstance(node.value, ast.Call)
+                and hasattr(node.value.func, "attr")
+            ) and any(
+                field_type in node.value.func.attr
+                for field_type in self.DJANGO_FIELD_TYPES
+            ):
+                self.models[self.current_model].add(target.id)
+
+
+def extract_model_fields(models_file: str) -> Dict[str, Set[str]]:
+    """
+    Extract fields from Django models file.
+
+    Parameters
+    ----------
+    models_file : str
+        A models.py file that defines Django models.
+
+    Returns
+    -------
+    Dict[str, Set[str]]
+        The fields from the models file extracted into a dictionary for future processing.
+    """
+    with open(models_file, "r", encoding="utf-8") as f:
+        content = f.read().strip()
+        # Skip any empty lines at the beginning.
+        while content.startswith("\n"):
+            content = content[1:]
+
+    try:
+        tree = ast.parse(content)
+    except SyntaxError as e:
+        raise SyntaxError(
+            f"Failed to parse {models_file}. Make sure it's a valid Python file. Error: {str(e)}"
+        ) from e
+
+    visitor = DjangoModelVisitor()
+    visitor.visit(tree)
+
+    return visitor.models

ts_backend_check/parsers/typescript_parser.py

@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""
+Module for parsing TypeScript interfaces and types.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Dict, List, Set
+
+
+@dataclass
+class TypeScriptInterface:
+    """
+    Represents a TypeScript interface with its fields and parent interfaces.
+    """
+
+    name: str
+    fields: Set[str]
+    parents: List[str]
+
+
+class TypeScriptParser:
+    """
+    Parser for TypeScript interface files.
+
+    Parameters
+    ----------
+    file_path : str
+        The file path for the TypeScript file to parse.
+    """
+
+    def __init__(self, file_path: str) -> None:
+        self.file_path = file_path
+        with open(file_path, "r", encoding="utf-8") as f:
+            self.content = f.read()
+
+    def parse_interfaces(self) -> Dict[str, TypeScriptInterface]:
+        """
+        Parse TypeScript interfaces from the file.
+
+        Returns
+        -------
+        Dict[str, TypeScriptInterface]
+            The interface parsed into a dictionary for future processing.
+        """
+        interfaces = {}
+        interface_pattern = (
+            r"(?:export\s+|declare\s+)?interface\s+(\w+)"
+            r"(?:\s+extends\s+([^{]+))?\s*{([\s\S]*?)}"
+        )
+
+        for match in re.finditer(interface_pattern, self.content):
+            name = match.group(1)
+            parents = (
+                [p.strip() for p in match.group(2).split(",")] if match.group(2) else []
+            )
+            fields = self._extract_fields(match.group(3))
+
+            interfaces[name] = TypeScriptInterface(name, fields, parents)
+
+        return interfaces
+
+    def get_backend_only_fields(self) -> Set[str]:
+        """
+        Extract fields marked as backend-only in comments.
+
+        Returns
+        -------
+        Set[str]
+            The field names that are marked with a backend-only identifier to ignore them.
+        """
+        patterns = [
+            r"//.*?Note:\s*(\w+)\s+is\s+backend\s+only",
+            r"//.*?(\w+)\s+is\s+backend\s+only",
+            r"//\s*@backend-only\s+(\w+)",
+            r"//.*?backend-only:\s*(\w+)",
+        ]
+        return {
+            match for pattern in patterns for match in re.findall(pattern, self.content)
+        }
+
+    @staticmethod
+    def _extract_fields(interface_body: str) -> Set[str]:
+        """
+        Extract field names from interface body.
+
+        Parameters
+        ----------
+        interface_body : str
+            A string representation of the interface body of the model.
+
+        Returns
+        -------
+        Set[str]
+            The field names from the model interface body.
+        """
+        fields = set()
+
+        # Regular fields
+        fields.update(re.findall(r"(?://[^\n]*\n)*\s*(\w+)\s*[?]?\s*:", interface_body))
+
+        # Readonly fields
+        fields.update(re.findall(r"readonly\s+(\w+)\s*[?]?\s*:", interface_body))
+
+        return fields

ts_backend_check/utils.py

@@ -6,7 +6,7 @@ Utility functions for ts-backend-check.
 
 def snake_to_camel(input_str: str) -> str:
     """
-    Convert snake_case to camelCase.
+    Convert snake_case to camelCase while preserving existing camelCase components.
 
     Parameters
     ----------
@@ -17,6 +17,23 @@ def snake_to_camel(input_str: str) -> str:
     -------
     str
         The camelCase version of the input string.
+
+    Examples
+    --------
+    hello_world -> helloWorld, alreadyCamelCase -> alreadyCamelCase
     """
-    components = input_str.split("_")
-    return components[0] + "".join(x.title() for x in components[1:])
+    if not input_str or input_str.startswith("_"):
+        return input_str
+
+    words = input_str.split("_")
+    result = words[0].lower()
+
+    for word in words[1:]:
+        if word:
+            if any(c.isupper() for c in word[1:]):
+                result += word[0].upper() + word[1:]
+
+            else:
+                result += word[0].upper() + word[1:].lower()
+
+    return result

ts_backend_check-1.2.0.data/data/requirements.txt

@@ -0,0 +1,26 @@
+#
+# This file is autogenerated by pip-compile with Python 3.13
+# by the following command:
+#
+#    pip-compile requirements.in
+#
+certifi>=2025.11.12
+    # via requests
+charset-normalizer>=3.4.4
+    # via requests
+idna>=3.11
+    # via requests
+markdown-it-py>=4.0.0
+    # via rich
+mdurl>=0.1.2
+    # via markdown-it-py
+pygments>=2.19.2
+    # via rich
+pyyaml>=6.0.3
+    # via -r requirements.in
+requests>=2.32.5
+    # via -r requirements.in
+rich>=14.2.0
+    # via -r requirements.in
+urllib3>=2.6.2
+    # via requests

{ts_backend_check-1.0.0.dist-info → ts_backend_check-1.2.0.dist-info}/METADATA

@@ -1,25 +1,54 @@
 Metadata-Version: 2.4
 Name: ts-backend-check
-Version: 1.0.0
-Summary: ts-backend-check is a Python package used to check TypeScript types against their corresponding backend models to assure that all fields have been accounted for.
+Version: 1.2.0
+Summary: Check TypeScript types against their corresponding backend models to assure that all fields have been accounted for.
 Home-page: https://github.com/activist-org/ts-backend-check
 Author: ts-backend-check developers
-Author-email: andrew.t.mcallister@gmail.com
-Requires-Python: >=3.8
+Author-email: team@activist.org
+License: : OSI Approved :: GNU License
+Keywords: backend,typescript,validation,ci,cli
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: click>=8.1
+Requires-Dist: certifi>=2025.11.12
+Requires-Dist: charset-normalizer>=3.4.4
+Requires-Dist: idna>=3.11
+Requires-Dist: markdown-it-py>=4.0.0
+Requires-Dist: mdurl>=0.1.2
+Requires-Dist: pygments>=2.19.2
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich>=14.2.0
+Requires-Dist: urllib3>=2.6.2
+Dynamic: author
 Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license-file
+Dynamic: requires-dist
 Dynamic: requires-python
+Dynamic: summary
 
 <div align="center">
-  <a href="https://github.com/activist-org/ts-backend-check"><img src="https://raw.githubusercontent.com/activist-org/ts-backend-check/main/.github/resources/TSBECheckGitHubBanner.png" width=1024 alt="TSBE Check logo"></a>
+  <a href="https://github.com/activist-org/ts-backend-check"><img src="https://raw.githubusercontent.com/activist-org/ts-backend-check/main/.github/resources/TSBackendCheckGitHubBanner.png" width=1024 alt="TS Backend Check logo"></a>
 </div>
 
 [![rtd](https://img.shields.io/readthedocs/ts-backend-check.svg?label=%20&logo=read-the-docs&logoColor=ffffff)](http://ts-backend-check.readthedocs.io/en/latest/)
-[![ci_backend](https://img.shields.io/github/actions/workflow/status/activist-org/ts-backend-check/pr_ci.yaml?branch=main&label=%20&logo=pytest&logoColor=ffffff)](https://github.com/activist-org/ts-backend-check/actions/workflows/pr_ci_backend.yaml)
+[![pr_ci](https://img.shields.io/github/actions/workflow/status/activist-org/ts-backend-check/pr_ci.yaml?branch=main&label=%20&logo=ruff&logoColor=ffffff)](https://github.com/activist-org/ts-backend-check/actions/workflows/pr_ci.yaml)
+[![python_package_ci](https://img.shields.io/github/actions/workflow/status/activist-org/ts-backend-check/python_package_ci.yaml?branch=main&label=%20&logo=pytest&logoColor=ffffff)](https://github.com/activist-org/ts-backend-check/actions/workflows/python_package_ci.yaml)
 [![issues](https://img.shields.io/github/issues/activist-org/ts-backend-check?label=%20&logo=github)](https://github.com/activist-org/ts-backend-check/issues)
 [![python](https://img.shields.io/badge/Python-4B8BBE.svg?logo=python&logoColor=ffffff)](https://github.com/activist-org/ts-backend-check/blob/main/CONTRIBUTING.md)
 [![pypi](https://img.shields.io/pypi/v/ts-backend-check.svg?label=%20&color=4B8BBE)](https://pypi.org/project/ts-backend-check/)
@@ -38,10 +67,10 @@ Dynamic: requires-python
 
 - [Usage](#usage-)
 - [Contributing](#contributing-)
-- [Environment setup](#environment-setup)
+- [Environment setup](#environment-setup-)
 - [Contributors](#contributors-)
 
-<a id="usage"></a>
+<a id="usage-"></a>
 
 ## Usage [`⇧`](#contents)
 
@@ -51,6 +80,11 @@ Dynamic: requires-python
 pip install ts-backend-check
 ```
 
+### Command Options
+
+- `backend-model-file` (`bmf`): Path to the backend model file (e.g. Python class)
+- `typescript-file` (`tsf`): Path to the TypeScript interface/type file
+
 ### Basic Usage
 
 The CLI provides a simple interface to check TypeScript types against backend models:
@@ -60,31 +94,19 @@ The CLI provides a simple interface to check TypeScript types against backend mo
 ts-backend-check --help
 
 # Check a TypeScript type against a backend model:
-ts-backend-check check <typescript_file> <backend_model>
+ts-backend-check -bmf <backend-model-file> -tsf <typescript-file>
 
 # Example command:
-ts-backend-check check src/types/user.ts src/models/user.py
-```
-
-### Command Options
-
-- `check`: Compare TypeScript types with backend models
-  - `typescript_file`: Path to the TypeScript interface/type file
-  - `backend_model`: Path to the backend model file (e.g. Python class)
-
-### Version Information
-
-```bash
-ts-backend-check --version
+ts-backend-check -bmf src/models/user.py -tsf src/types/user.ts
 ```
 
-<a id="contributing"></a>
+<a id="contributing-"></a>
 
 # Contributing [`⇧`](#contents)
 
-<a href="https://matrix.to/#/#activist_community:matrix.org"><img src="https://raw.githubusercontent.com/activist-org/Organization/main/resources/images/logos/MatrixLogoGrey.png" height="50" alt="Public Matrix Chat" align="right"></a>
+<a href="https://matrix.to/#/#activist_community:matrix.org"><img src="https://raw.githubusercontent.com/activist-org/Organization/main/resources/images/logos/MatrixLogoGrey.png" width="175" alt="Public Matrix Chat" align="right"></a>
 
-activist uses [Matrix](https://matrix.org/) for internal communication. You're more than welcome to [join us in our public chat rooms](https://matrix.to/#/#activist_community:matrix.org) to share ideas, ask questions or just say hi to the team :)
+activist uses [Matrix](https://matrix.org/) for internal communication. You're more than welcome to [join us in our public chat rooms](https://matrix.to/#/#activist_community:matrix.org) to share ideas, ask questions or just say hi to the team :) We'd suggest that you use the [Element](https://element.io/) client and [Element X](https://element.io/app) for a mobile app.
 
 Please see the [contribution guidelines](CONTRIBUTING.md) if you are interested in contributing. Work that is in progress or could be implemented is tracked in the [issues](https://github.com/activist-org/ts-backend-check/issues) and [projects](https://github.com/activist-org/ts-backend-check/projects).
 
@@ -95,7 +117,7 @@ Also check the [`-next release-`](https://github.com/activist-org/ts-backend-che
 
 We would be happy to discuss granting you further rights as a contributor after your first pull requests, with a maintainer role then being possible after continued interest in the project. activist seeks to be an inclusive, diverse and supportive organization. We'd love to have you on the team!
 
-<a id="how-you-can-help"></a>
+<a id="how-you-can-help-"></a>
 
 ## How you can help [`⇧`](#contents)
 
@@ -103,7 +125,7 @@ We would be happy to discuss granting you further rights as a contributor after
 - Working with us on [new features](https://github.com/activist-org/ts-backend-check/issues?q=is%3Aissue+is%3Aopen+label%3Afeature) ✨
 - [Documentation](https://github.com/activist-org/ts-backend-check/issues?q=is%3Aissue+is%3Aopen+label%3Adocumentation) for onboarding and project cohesion 📝
 
-<a id="environment-setup"></a>
+<a id="environment-setup-"></a>
 
 # Environment setup [`⇧`](#contents)
 

ts_backend_check-1.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+ts_backend_check/__init__.py,sha256=HSiEqWvU3Q4a6D7tYsoq3-B-g1HdUOGngEeGV45j8ak,172
+ts_backend_check/checker.py,sha256=ISPl_1H7dXb7DcOl6erdxEhx61xQBJxtHuYkUuEqrck,5792
+ts_backend_check/django_parser.py,sha256=CFg4-zV5BsVhuq-nVQEYD9nS25JSaHbIs2Xr3LE3KWY,3241
+ts_backend_check/typescript_parser.py,sha256=BqBGOjsf-Wlh6ceaK-G2vLm5AMiEiwX-XnJQrr8P-gQ,2885
+ts_backend_check/utils.py,sha256=N9_25_wW2g3dkmGGLWHQj_AHsXI9Rx2XqRnYxT5i2Rk,897
+ts_backend_check/cli/__init__.py,sha256=wJK9tO9MtI10L0xRjrk7WP_qZZRBjbFw1U9jJbIbX7I,108
+ts_backend_check/cli/check_blank.py,sha256=gg6v01UYNmzs8eLasxauCaBCfN9esUtiAwqhqNTzE3w,3377
+ts_backend_check/cli/config.py,sha256=AgzjY3qbgW4ya5JJEdKaBQ9J8h0Ip-39xJNbAjFpA6s,4463
+ts_backend_check/cli/main.py,sha256=6g9Rf_m5H2cWUoPYPU_HEmkoUl6SLLai1Ni2BpgDz6U,4222
+ts_backend_check/cli/upgrade.py,sha256=P2LdIDCLdOFs-fOMuKLQoUMijQIyKEIA5PFZVsAUwDg,2952
+ts_backend_check/cli/version.py,sha256=lsocMaxAfF-FHW9O-NGH1sAo6svjuLgdGFxaC-XVoZc,2845
+ts_backend_check/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ts_backend_check/parsers/django_parser.py,sha256=U5OP6IyrSdwI9rDUGU4GbWTDfozwhretWg7lmF6QGB8,3242
+ts_backend_check/parsers/typescript_parser.py,sha256=BqBGOjsf-Wlh6ceaK-G2vLm5AMiEiwX-XnJQrr8P-gQ,2885
+ts_backend_check-1.2.0.data/data/requirements.txt,sha256=ixdwNPm86WRSX0oBBaNegCQL7HQP8evsCRAdEFHLxGk,540
+ts_backend_check-1.2.0.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ts_backend_check-1.2.0.dist-info/METADATA,sha256=FDqxUd_nslUpUNEtk5sAHxEkATcDVkUAJkBMVYkf0rA,10416
+ts_backend_check-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ts_backend_check-1.2.0.dist-info/entry_points.txt,sha256=QeY7RJu20otBnQlhMMZxPL8nB3mP3M3U3h3nOlSFWSU,68
+ts_backend_check-1.2.0.dist-info/top_level.txt,sha256=VzfNWQ3fPNdl-OBdtUKsUWR8Asdd27E3OJNUg2oQU8Y,17
+ts_backend_check-1.2.0.dist-info/RECORD,,

ts_backend_check-1.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ts-backend-check = ts_backend_check.cli.main:main

ts_backend_check-1.0.0.data/data/requirements.txt

@@ -1,6 +0,0 @@
-#
-# This file is autogenerated by pip-compile with Python 3.13
-# by the following command:
-#
-#    pip-compile requirements.in
-#

ts_backend_check-1.0.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-ts_backend_check/__init__.py,sha256=5Y_YDmaFl9cjVy1GqGeml-QaPUpcJyWgjCYe_vJoHvw,156
-ts_backend_check/checker.py,sha256=8mLtLBt6ok2cDgt-3u8yb3hClf-3ojU8zIsqL2z_GdQ,5727
-ts_backend_check/django_parser.py,sha256=CFg4-zV5BsVhuq-nVQEYD9nS25JSaHbIs2Xr3LE3KWY,3241
-ts_backend_check/typescript_parser.py,sha256=BqBGOjsf-Wlh6ceaK-G2vLm5AMiEiwX-XnJQrr8P-gQ,2885
-ts_backend_check/utils.py,sha256=Kfa6ZvjnsGrGJJX18FhfzmQtjMrjPwfECZiZL4zgGRQ,475
-ts_backend_check/cli/__init__.py,sha256=bxThVZZgFRXoWgZ4pasljY6ATZPTJVh_KeBebweDJb0,129
-ts_backend_check/cli/main.py,sha256=RUJsonWBUnCqg93ayuDo0LJYhCLKuVb9V9Ycx5cbts4,1636
-ts_backend_check-1.0.0.data/data/requirements.txt,sha256=0FbFr7FTG31FEs_FMsN3MrAIFJIeGdDC6POOOb2FeA0,134
-ts_backend_check-1.0.0.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ts_backend_check-1.0.0.dist-info/METADATA,sha256=1hA_CrBvSqePiw3G0ZBAvm5kEmGBRSYHGlUOmsagJnw,9084
-ts_backend_check-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ts_backend_check-1.0.0.dist-info/entry_points.txt,sha256=6_OttJoqgUr1BZYjy6Rcx5g0iYcwJD2o1c5q_6OcXzw,58
-ts_backend_check-1.0.0.dist-info/top_level.txt,sha256=VzfNWQ3fPNdl-OBdtUKsUWR8Asdd27E3OJNUg2oQU8Y,17
-ts_backend_check-1.0.0.dist-info/RECORD,,

ts_backend_check-1.0.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-ts-backend-check = ts_backend_check:cli