amplify-excel-migrator 1.0.0__py3-none-any.whl

amplify_excel_migrator-1.0.0.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: amplify-excel-migrator
+Version: 1.0.0
+Summary: A CLI tool to migrate Excel data to AWS Amplify
+Home-page: https://github.com/EyalPoly/amplify-excel-migrator
+Author: Eyal Politansky
+Author-email: 10eyal10@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: requests>=2.26.0
+Requires-Dist: boto3>=1.18.0
+Requires-Dist: pycognito>=2023.5.0
+Requires-Dist: PyJWT>=2.0.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: openpyxl>=3.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: setuptools>=80.0.0; extra == "dev"
+Requires-Dist: wheel>=0.40.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Amplify Excel Migrator
+
+A CLI tool to migrate data from Excel files to AWS Amplify GraphQL API.
+Developed for the MECO project - https://github.com/sworgkh/meco-observations-amplify
+
+## Installation
+
+### From GitHub
+
+Install directly from GitHub:
+
+```bash
+pip install git+https://github.com/EyalPoly/amplify-excel-migrator.git
+```
+
+### From Source
+
+Clone the repository and install:
+
+```bash
+git clone https://github.com/EyalPoly/amplify-excel-migrator.git
+cd amplify-excel-migrator
+pip install .
+```
+
+### For Development
+
+Install with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+This installs the package in editable mode with pytest and other development tools.
+
+## Usage
+
+The tool has three subcommands:
+
+### 1. Configure (First Time Setup)
+
+Save your AWS Amplify configuration:
+
+```bash
+amplify-migrator config
+```
+
+This will prompt you for:
+- Excel file path
+- AWS Amplify API endpoint
+- AWS Region
+- Cognito User Pool ID
+- Cognito Client ID
+- Admin username
+
+Configuration is saved to `~/.amplify-migrator/config.json` (passwords are never saved).
+
+### 2. Show Configuration
+
+View your current saved configuration:
+
+```bash
+amplify-migrator show
+```
+
+### 3. Run Migration
+
+Run the migration using your saved configuration:
+
+```bash
+amplify-migrator migrate
+```
+
+You'll only be prompted for your password (for security, passwords are never cached).
+
+### Quick Start
+
+```bash
+# First time: configure the tool
+amplify-migrator config
+
+# View current configuration
+amplify-migrator show
+
+# Run migration (uses saved config)
+amplify-migrator migrate
+
+# View help
+amplify-migrator --help
+```
+
+### Example: Configuration
+
+```
+╔════════════════════════════════════════════════════╗
+║        Amplify Migrator - Configuration Setup      ║
+╚════════════════════════════════════════════════════╝
+
+📋 Configuration Setup:
+------------------------------------------------------
+Excel file path [data.xlsx]: my-data.xlsx
+AWS Amplify API endpoint: https://xxx.appsync-api.us-east-1.amazonaws.com/graphql
+AWS Region [us-east-1]:
+Cognito User Pool ID: us-east-1_xxxxx
+Cognito Client ID: your-client-id
+Admin Username: admin@example.com
+
+✅ Configuration saved successfully!
+💡 You can now run 'amplify-migrator migrate' to start the migration.
+```
+
+### Example: Migration
+
+```
+╔════════════════════════════════════════════════════╗
+║             Migrator Tool for Amplify              ║
+╠════════════════════════════════════════════════════╣
+║   This tool requires admin privileges to execute   ║
+╚════════════════════════════════════════════════════╝
+
+🔐 Authentication:
+------------------------------------------------------
+Admin Password: ********
+```
+
+## Requirements
+
+- Python 3.8+
+- AWS Amplify GraphQL API
+- AWS Cognito User Pool
+- Admin access to the Cognito User Pool
+
+## Features
+
+- **Configuration caching** - Save your setup, reuse it for multiple migrations
+- **Interactive prompts** - Easy step-by-step configuration
+- **Custom types and enums** - Full support for Amplify custom types
+- **Duplicate detection** - Automatically skips existing records
+- **Async uploads** - Fast parallel uploads for better performance
+- **MFA support** - Works with multi-factor authentication
+- **Automatic type parsing** - Smart field type detection and conversion
+
+## Excel File Format
+
+The Excel file should have:
+- One sheet per Amplify model (sheet name must match model name)
+- Column names matching the model field names
+- First row as headers
+
+### Example Excel Structure
+
+**Sheet: User**
+| name | email | age |
+|------|-------|-----|
+| John | john@example.com | 30 |
+| Jane | jane@example.com | 25 |
+
+**Sheet: Post**
+| title | content | userId |
+|-------|---------|--------|
+| First Post | Hello World | john@example.com |
+
+## License
+
+MIT

amplify_excel_migrator-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+amplify_client.py,sha256=fZ9LKCzEMOY3upNGaPCEuofVXI8IN2JemQFxTsQN6q8,26916
+migrator.py,sha256=03YO5n6jymPA5bDr1Ks6FeSwi7bb8lZ_9LBjFSJCDi8,12081
+model_field_parser.py,sha256=u7f55WYg6eRS-_iyq9swzxntqyUQMH9vaX3j-RUG76w,4328
+amplify_excel_migrator-1.0.0.dist-info/licenses/LICENSE,sha256=i8Sf8mXscGI9l-HTQ5RLQkAJU6Iv5hPYctJksPY70U0,1071
+amplify_excel_migrator-1.0.0.dist-info/METADATA,sha256=7qXRVir9VJq6NEM7B1WswHe0jx4YF95iutb2nPWMLog,5552
+amplify_excel_migrator-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amplify_excel_migrator-1.0.0.dist-info/entry_points.txt,sha256=Ifd7YnV4lNbjFbbnjsmlHWiIAfIpiC5POgJtxfSlDT4,51
+amplify_excel_migrator-1.0.0.dist-info/top_level.txt,sha256=C-ffRe3F26GYiM7f6xy-pPvbwnh7Wnieyt-jS-cbdTU,43
+amplify_excel_migrator-1.0.0.dist-info/RECORD,,

amplify_excel_migrator-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

amplify_excel_migrator-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+amplify-migrator = migrator:main

amplify_excel_migrator-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eyal Politansky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

amplify_excel_migrator-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+amplify_client
+migrator
+model_field_parser

migrator.py

@@ -0,0 +1,301 @@
+import argparse
+import json
+import logging
+import re
+import sys
+from getpass import getpass
+from pathlib import Path
+from typing import Dict, Any
+
+import pandas as pd
+
+from amplify_client import AmplifyClient
+from model_field_parser import ModelFieldParser
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+CONFIG_DIR = Path.home() / '.amplify-migrator'
+CONFIG_FILE = CONFIG_DIR / 'config.json'
+
+
+class ExcelToAmplifyMigrator:
+    def __init__(self, excel_file_path: str):
+        self.model_field_parser = ModelFieldParser()
+        self.excel_file_path = excel_file_path
+        self.amplify_client = None
+
+    def init_client(self, api_endpoint: str, region: str, user_pool_id: str, is_aws_admin: bool = False,
+                    client_id: str = None, username: str = None, aws_profile: str = None):
+
+        self.amplify_client = AmplifyClient(
+            api_endpoint=api_endpoint,
+            user_pool_id=user_pool_id,
+            region=region,
+            client_id=client_id,
+        )
+
+        try:
+            self.amplify_client.init_cognito_client(is_aws_admin=is_aws_admin, username=username,
+                                                    aws_profile=aws_profile)
+
+        except RuntimeError or Exception:
+            sys.exit(1)
+
+    def authenticate(self, username: str, password: str) -> bool:
+        return self.amplify_client.authenticate(username, password)
+
+    def run(self):
+        all_sheets = self.read_excel()
+
+        for sheet_name, df in all_sheets.items():
+            logger.info(f"Processing {sheet_name} sheet with {len(df)} rows")
+            self.process_sheet(df, sheet_name)
+
+    def read_excel(self) -> Dict[str, Any]:
+        logger.info(f"Reading Excel file: {self.excel_file_path}")
+        all_sheets = pd.read_excel(self.excel_file_path, sheet_name=None)
+
+        logger.info(f"Loaded {len(all_sheets)} sheets from Excel")
+        return all_sheets
+
+    def process_sheet(self, df: pd.DataFrame, sheet_name: str):
+        parsed_model_structure = self.get_parsed_model_structure(sheet_name)
+        records = self.transform_rows_to_records(df, parsed_model_structure)
+
+        # confirm = input(f"\nUpload {len(records)} records of {sheet_name} to Amplify? (yes/no): ")
+        # if confirm.lower() != 'yes':
+        #     logger.info("Upload cancelled for {sheet_name} sheet")
+        #     return
+
+        success_count, error_count = self.amplify_client.upload(records, sheet_name, parsed_model_structure)
+
+        logger.info(f"=== Upload of Excel sheet: {sheet_name} Complete ===")
+        logger.info(f"✅ Success: {success_count}")
+        logger.info(f"❌ Failed: {error_count}")
+        logger.info(f"📊 Total: {len(records)}")
+
+    def transform_rows_to_records(self, df: pd.DataFrame, parsed_model_structure: Dict[str, Any]) -> list[Any]:
+        records = []
+        df.columns = [self.to_camel_case(c) for c in df.columns]
+        for idx, row in df.iterrows():
+            try:
+                record = self.transform_row_to_record(row, parsed_model_structure)
+                if record:
+                    records.append(record)
+            except Exception as e:
+                logger.error(f"Error transforming row {idx}: {e}")
+
+        logger.info(f"Prepared {len(records)} records for upload")
+
+        return records
+
+    def get_parsed_model_structure(self, sheet_name: str) -> Dict[str, Any]:
+        model_structure = self.amplify_client.get_model_structure(sheet_name)
+        return self.model_field_parser.parse_model_structure(model_structure)
+
+    def transform_row_to_record(self, row: pd.Series, parsed_model_structure: Dict[str, Any]) -> dict[Any, Any] | None:
+        """Transform a DataFrame row to Amplify model format"""
+
+        model_record = {}
+
+        for field in parsed_model_structure['fields']:
+            input = self.parse_input(row, field, parsed_model_structure)
+            if input:
+                model_record[field['name']] = input
+
+        return model_record
+
+    def parse_input(self, row: pd.Series, field: Dict[str, Any], parsed_model_structure: Dict[str, Any]) -> Any:
+        field_name = field['name'][:-2] if field['is_id'] else field['name']
+        if field_name not in row.index or pd.isna(row[field_name]):
+            if field['is_required']:
+                raise ValueError(f"Required field '{field_name}' is missing in row {row.name}")
+            else:
+                return None
+
+        value = row.get(field['name'])
+        if field['is_id']:
+            related_model = (temp := field['name'][:-2])[0].upper() + temp[1:]
+            record = self.amplify_client.get_record(related_model, parsed_model_structure=parsed_model_structure,
+                                                    value=value, fields=['id'])
+            if record:
+                if record['id'] is None and field['is_required']:
+                    raise ValueError(f"{related_model}: {value} does not exist")
+                else:
+                    value = record['id']
+            else:
+                raise ValueError(f"Error fetching related record {related_model}: {value}")
+
+        return value
+
+    @staticmethod
+    def to_camel_case(s: str) -> str:
+        # Handle PascalCase
+        s_with_spaces = re.sub(r'(?<!^)(?=[A-Z])', ' ', s)
+
+        parts = re.split(r'[\s_\-]+', s_with_spaces.strip())
+        return parts[0].lower() + ''.join(word.capitalize() for word in parts[1:])
+
+
+def get_config_value(prompt: str, default: str = '', secret: bool = False) -> str:
+    if default:
+        prompt = f"{prompt} [{default}]: "
+    else:
+        prompt = f"{prompt}: "
+
+    if secret:
+        value = getpass(prompt)
+    else:
+        value = input(prompt)
+
+    return value.strip() if value.strip() else default
+
+
+def save_config(config: Dict[str, str]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    cache_config = {k: v for k, v in config.items() if k not in ['password', 'ADMIN_PASSWORD']}
+
+    with open(CONFIG_FILE, 'w') as f:
+        json.dump(cache_config, f, indent=2)
+
+    logger.info(f"✅ Configuration saved to {CONFIG_FILE}")
+
+
+def load_cached_config() -> Dict[str, str]:
+    if not CONFIG_FILE.exists():
+        return {}
+
+    try:
+        with open(CONFIG_FILE, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.warning(f"Failed to load cached config: {e}")
+        return {}
+
+
+def get_cached_or_prompt(key: str, prompt: str, cached_config: Dict, default: str = '', secret: bool = False) -> str:
+    if key in cached_config:
+        return cached_config[key]
+
+    return get_config_value(prompt, default, secret)
+
+
+def cmd_show(args=None):
+    print("""
+    ╔════════════════════════════════════════════════════╗
+    ║        Amplify Migrator - Current Configuration    ║
+    ╚════════════════════════════════════════════════════╝
+    """)
+
+    cached_config = load_cached_config()
+
+    if not cached_config:
+        print("\n❌ No configuration found!")
+        print("💡 Run 'amplify-migrator config' first to set up your configuration.")
+        return
+
+    print("\n📋 Cached Configuration:")
+    print("-" * 54)
+    print(f"Excel file path:      {cached_config.get('excel_path', 'N/A')}")
+    print(f"API endpoint:         {cached_config.get('api_endpoint', 'N/A')}")
+    print(f"AWS Region:           {cached_config.get('region', 'N/A')}")
+    print(f"User Pool ID:         {cached_config.get('user_pool_id', 'N/A')}")
+    print(f"Client ID:            {cached_config.get('client_id', 'N/A')}")
+    print(f"Admin Username:       {cached_config.get('username', 'N/A')}")
+    print("-" * 54)
+    print(f"\n📍 Config location: {CONFIG_FILE}")
+    print(f"💡 Run 'amplify-migrator config' to update configuration.")
+
+
+def cmd_config(args=None):
+    print("""
+    ╔════════════════════════════════════════════════════╗
+    ║        Amplify Migrator - Configuration Setup      ║
+    ╚════════════════════════════════════════════════════╝
+    """)
+
+    config = {'excel_path': get_config_value('Excel file path', 'data.xlsx'),
+              'api_endpoint': get_config_value('AWS Amplify API endpoint'),
+              'region': get_config_value('AWS Region', 'us-east-1'),
+              'user_pool_id': get_config_value('Cognito User Pool ID'),
+              'client_id': get_config_value('Cognito Client ID'),
+              'username': get_config_value('Admin Username')}
+
+    save_config(config)
+    print("\n✅ Configuration saved successfully!")
+    print(f"💡 You can now run 'amplify-migrator migrate' to start the migration.")
+
+
+def cmd_migrate(args=None):
+    print("""
+    ╔════════════════════════════════════════════════════╗
+    ║             Migrator Tool for Amplify              ║
+    ╠════════════════════════════════════════════════════╣
+    ║   This tool requires admin privileges to execute   ║
+    ╚════════════════════════════════════════════════════╝
+    """)
+
+    cached_config = load_cached_config()
+
+    if not cached_config:
+        print("\n❌ No configuration found!")
+        print("💡 Run 'amplify-migrator config' first to set up your configuration.")
+        sys.exit(1)
+
+    excel_path = get_cached_or_prompt('excel_path', 'Excel file path', cached_config, 'data.xlsx')
+    api_endpoint = get_cached_or_prompt('api_endpoint', 'AWS Amplify API endpoint', cached_config)
+    region = get_cached_or_prompt('region', 'AWS Region', cached_config, 'us-east-1')
+    user_pool_id = get_cached_or_prompt('user_pool_id', 'Cognito User Pool ID', cached_config)
+    client_id = get_cached_or_prompt('client_id', 'Cognito Client ID', cached_config)
+    username = get_cached_or_prompt('username', 'Admin Username', cached_config)
+
+    print("\n🔐 Authentication:")
+    print("-" * 54)
+    password = get_config_value('ADMIN_PASSWORD', 'Admin Password', secret=True)
+
+    migrator = ExcelToAmplifyMigrator(excel_path)
+    migrator.init_client(api_endpoint, region, user_pool_id, client_id=client_id,
+                         username=username)
+    if not migrator.authenticate(username, password):
+        return
+
+    migrator.run()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Amplify Excel Migrator - Migrate Excel data to AWS Amplify GraphQL API',
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+
+    config_parser = subparsers.add_parser('config', help='Configure the migration tool')
+    config_parser.set_defaults(func=cmd_config)
+
+    show_parser = subparsers.add_parser('show', help='Show current configuration')
+    show_parser.set_defaults(func=cmd_show)
+
+    migrate_parser = subparsers.add_parser('migrate', help='Run the migration')
+    migrate_parser.set_defaults(func=cmd_migrate)
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    # For IDE debugging: set the command you want to test
+    # Uncomment and modify one of these lines:
+
+    # sys.argv = ['migrator.py', 'config']  # Test config command
+    # sys.argv = ['migrator.py', 'show']    # Test show command
+    # sys.argv = ['migrator.py', 'migrate'] # Test migrate command
+
+    main()

model_field_parser.py

@@ -0,0 +1,134 @@
+from typing import Dict, Any
+
+
+class ModelFieldParser:
+    """Parse GraphQL model fields from introspection results"""
+
+    def __init__(self):
+        self.scalar_types = {
+            'String', 'Int', 'Float', 'Boolean',
+            'AWSDate', 'AWSTime', 'AWSDateTime', 'AWSTimestamp',
+            'AWSEmail', 'AWSJSON', 'AWSURL', 'AWSPhone', 'AWSIPAddress'
+        }
+        self.metadata_fields = {'id', 'createdAt', 'updatedAt', 'owner'}
+
+    def parse_model_structure(self, introspection_result: Dict) -> Dict[str, Any]:
+        if 'data' in introspection_result and '__type' in introspection_result['data']:
+            type_data = introspection_result['data']['__type']
+        else:
+            type_data = introspection_result
+
+        model_info = {
+            'name': type_data.get('name'),
+            'kind': type_data.get('kind'),
+            'description': type_data.get('description'),
+            'fields': []
+        }
+
+        if type_data.get('fields'):
+            for field in type_data['fields']:
+                parsed_field = self._parse_field(field)
+                model_info['fields'].append(parsed_field) if parsed_field else None
+
+        return model_info
+
+    def _parse_field(self, field: Dict) -> Dict[str, Any]:
+        base_type = self._get_base_type_name(field.get('type', {}))
+        if 'Connection' in base_type or field.get('name') in self.metadata_fields or self._get_type_kind(
+                field.get('type', {})) in ['OBJECT', 'INTERFACE']:
+            return {}
+
+        field_info = {
+            'name': field.get('name'),
+            'description': field.get('description'),
+            'type': base_type,
+            'is_required': self._is_required_field(field.get('type', {})),
+            'is_list': self._is_list_type(field.get('type', {})),
+            'is_scalar': base_type in self.scalar_types,
+            'is_id': base_type == 'ID',
+            'is_enum': field.get('type', {}).get('kind') == 'ENUM',
+        }
+
+        return field_info
+
+    def _parse_type(self, type_obj: Dict) -> Dict[str, Any]:
+        """
+        Recursively parse type information
+        """
+
+        if not type_obj:
+            return {'name': 'Unknown', 'kind': 'UNKNOWN'}
+
+        type_info = {
+            'name': type_obj.get('name'),
+            'kind': type_obj.get('kind'),
+            'full_type': self._get_full_type_string(type_obj)
+        }
+
+        # If there's nested type info (NON_NULL, LIST), include it
+        if type_obj.get('ofType'):
+            type_info['of_type'] = self._parse_type(type_obj['ofType'])
+
+        return type_info
+
+    def _get_full_type_string(self, type_obj: Dict) -> str:
+        """
+        Get human-readable type string (e.g., '[String!]!')
+        """
+
+        if not type_obj:
+            return 'Unknown'
+
+        if type_obj.get('name'):
+            return type_obj['name']
+
+        if type_obj['kind'] == 'NON_NULL':
+            inner = self._get_full_type_string(type_obj.get('ofType', {}))
+            return f"{inner}!"
+
+        if type_obj['kind'] == 'LIST':
+            inner = self._get_full_type_string(type_obj.get('ofType', {}))
+            return f"[{inner}]"
+
+        return type_obj.get('kind', 'Unknown')
+
+    def _get_base_type_name(self, type_obj: Dict) -> str:
+        """
+        Get the base type name, unwrapping NON_NULL and LIST wrappers
+        """
+
+        if not type_obj:
+            return 'Unknown'
+
+        if type_obj.get('name'):
+            return type_obj['name']
+
+        if type_obj.get('ofType'):
+            return self._get_base_type_name(type_obj['ofType'])
+
+        return 'Unknown'
+
+    def _get_type_kind(self, type_obj: Dict) -> str:
+        if not type_obj:
+            return 'UNKNOWN'
+
+        if type_obj['kind'] in ['NON_NULL', 'LIST'] and type_obj.get('ofType'):
+            return self._get_type_kind(type_obj['ofType'])
+
+        return type_obj.get('kind', 'UNKNOWN')
+
+    @staticmethod
+    def _is_required_field(type_obj: Dict) -> bool:
+        return type_obj and type_obj.get('kind') == 'NON_NULL'
+
+    def _is_list_type(self, type_obj: Dict) -> bool:
+        if not type_obj:
+            return False
+
+        if type_obj['kind'] == 'LIST':
+            return True
+
+        if type_obj.get('ofType'):
+            return self._is_list_type(type_obj['ofType'])
+
+        return False