Monody Documentation

# .env
MONODY_API_KEY=your_api_key_here
MONODY_BASE_URL=https://api.monody.dev

Authorization: Bearer YOUR_API_KEY

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.monody.dev/sessions

{
  "error": {
    "code": "INVALID_SCHEMA",
    "message": "The uploaded schema contains syntax errors",
    "details": {
      "line": 15,
      "column": 8,
      "description": "Expected ';' after property declaration"
    },
    "timestamp": "2024-12-12T10:00:00Z",
    "requestId": "req_abc123xyz"
  }
}

// monody-client.js
const fetch = require('node-fetch');
const FormData = require('form-data');
const fs = require('fs');

class MonodyClient {
  constructor(apiKey, baseUrl = 'https://api.monody.dev') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  async createSession(schemaPath, name, description) {
    const formData = new FormData();
    formData.append('schema', fs.createReadStream(schemaPath));
    formData.append('name', name);
    if (description) {
      formData.append('description', description);
    }

    const response = await fetch(`${this.baseUrl}/sessions`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        ...formData.getHeaders()
      },
      body: formData
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Failed to create session: ${error.error.message}`);
    }

    return response.json();
  }

  async generateData(endpoint, sessionId, options = {}) {
    const params = new URLSearchParams({
      sessionId,
      count: options.count || 10,
      ...(options.seed && { seed: options.seed }),
      ...(options.locale && { locale: options.locale })
    });

    const response = await fetch(
      `${this.baseUrl}/${endpoint}?${params}`,
      {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`
        }
      }
    );

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Failed to generate data: ${error.error.message}`);
    }

    const result = await response.json();
    return result.data;
  }

  async getSession(sessionId) {
    const response = await fetch(`${this.baseUrl}/sessions/${sessionId}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Failed to get session: ${error.error.message}`);
    }

    return response.json();
  }
}

// Usage example
async function main() {
  const client = new MonodyClient(process.env.MONODY_API_KEY);

  try {
    // Create session
    const session = await client.createSession(
      './schema/interface.ts',
      'blog-api',
      'Blog API mock data'
    );
    
    console.log('Session created:', session.sessionId);
    
    // Generate data
    const users = await client.generateData('users', session.sessionId, {
      count: 15,
      locale: 'en'
    });
    
    const posts = await client.generateData('posts', session.sessionId, {
      count: 50,
      seed: 'blog-posts-v1'
    });
    
    console.log(`Generated ${users.length} users and ${posts.length} posts`);
    
    // Save to files
    fs.writeFileSync('./data/users.json', JSON.stringify(users, null, 2));
    fs.writeFileSync('./data/posts.json', JSON.stringify(posts, null, 2));
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

// browser-client.js
class MonodyBrowserClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.monody.dev';
  }

  async createSessionFromFile(fileInput, name) {
    const file = fileInput.files[0];
    if (!file) {
      throw new Error('No file selected');
    }

    const formData = new FormData();
    formData.append('schema', file);
    formData.append('name', name);

    const response = await fetch(`${this.baseUrl}/sessions`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      },
      body: formData
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.error.message);
    }

    return response.json();
  }

  async generateData(endpoint, sessionId, count = 10) {
    const params = new URLSearchParams({
      sessionId,
      count: count.toString()
    });

    const response = await fetch(
      `${this.baseUrl}/${endpoint}?${params}`,
      {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`
        }
      }
    );

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.error.message);
    }

    const result = await response.json();
    return result.data;
  }
}

// HTML usage example
/*
<input type="file" id="schemaFile" accept=".ts,.json,.js">
<button onclick="uploadAndGenerate()">Generate Data</button>
<div id="results"></div>

<script>
const client = new MonodyBrowserClient('your-api-key');

async function uploadAndGenerate() {
  try {
    const fileInput = document.getElementById('schemaFile');
    const session = await client.createSessionFromFile(fileInput, 'web-demo');
    
    const users = await client.generateData('users', session.sessionId, 5);
    
    document.getElementById('results').innerHTML = 
      '<pre>' + JSON.stringify(users, null, 2) + '</pre>';
      
  } catch (error) {
    console.error('Error:', error);
    alert('Error: ' + error.message);
  }
}
</script>
*/

# monody_client.py
import requests
import json
from typing import Dict, List, Optional, Any
from pathlib import Path

class MonodyClient:
    def __init__(self, api_key: str, base_url: str = "https://api.monody.dev"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}'
        })

    def create_session(self, schema_path: str, name: str, description: Optional[str] = None) -> Dict[str, Any]:
        """Create a new Monody session by uploading a schema file."""
        with open(schema_path, 'rb') as schema_file:
            files = {'schema': schema_file}
            data = {'name': name}
            if description:
                data['description'] = description

            response = self.session.post(f'{self.base_url}/sessions', files=files, data=data)
            
            if not response.ok:
                error_data = response.json()
                raise Exception(f"Failed to create session: {error_data['error']['message']}")
            
            return response.json()

    def generate_data(self, endpoint: str, session_id: str, count: int = 10, 
                     seed: Optional[str] = None, locale: str = 'en') -> List[Dict[str, Any]]:
        """Generate mock data for a specific endpoint."""
        params = {
            'sessionId': session_id,
            'count': count,
            'locale': locale
        }
        if seed:
            params['seed'] = seed

        response = self.session.get(f'{self.base_url}/{endpoint}', params=params)
        
        if not response.ok:
            error_data = response.json()
            raise Exception(f"Failed to generate data: {error_data['error']['message']}")
        
        result = response.json()
        return result['data']

    def get_session(self, session_id: str) -> Dict[str, Any]:
        """Get information about a specific session."""
        response = self.session.get(f'{self.base_url}/sessions/{session_id}')
        
        if not response.ok:
            error_data = response.json()
            raise Exception(f"Failed to get session: {error_data['error']['message']}")
        
        return response.json()

    def save_data_to_file(self, data: List[Dict[str, Any]], filename: str):
        """Save generated data to a JSON file."""
        with open(filename, 'w') as f:
            json.dump(data, f, indent=2, default=str)

# Usage example
def main():
    import os
    
    client = MonodyClient(os.getenv('MONODY_API_KEY'))
    
    try:
        # Create session
        session = client.create_session(
            schema_path='./schemas/blog_schema.ts',
            name='blog-api-python',
            description='Blog API for Python integration'
        )
        
        print(f"Session created: {session['sessionId']}")
        
        # Generate different types of data
        users = client.generate_data('users', session['sessionId'], count=20)
        posts = client.generate_data('posts', session['sessionId'], count=100, seed='blog-v1')
        comments = client.generate_data('comments', session['sessionId'], count=500)
        
        print(f"Generated {len(users)} users, {len(posts)} posts, {len(comments)}")
        
        # Save to files
        client.save_data_to_file(users, 'users.json')
        client.save_data_to_file(posts, 'posts.json')
        client.save_data_to_file(comments, 'comments.json')
        
        # Print sample data
        print("\nSample user:")
        print(json.dumps(users[0], indent=2, default=str))
        
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()

# django_monody.py
from django.conf import settings
from django.core.management.base import BaseCommand
from django.apps import apps
import json
import os
from monody_client import MonodyClient

class MonodyDjangoIntegration:
    def __init__(self):
        self.client = MonodyClient(settings.MONODY_API_KEY)
        self.session_id = None

    def create_session_from_models(self, app_name: str):
        """Create a TypeScript interface from Django models."""
        app_config = apps.get_app_config(app_name)
        models = app_config.get_models()
        
        interfaces = []
        for model in models:
            interface_lines = [f"interface {model.__name__} {{"]
            
            for field in model._meta.fields:
                field_type = self._get_typescript_type(field)
                interface_lines.append(f"  {field.name}: {field_type};")
            
            interface_lines.append("}")
            interfaces.append("\n".join(interface_lines))
        
        schema_content = "\n\n".join(interfaces)
        
        # Save to temporary file
        schema_path = f"/tmp/{app_name}_schema.ts"
        with open(schema_path, 'w') as f:
            f.write(schema_content)
        
        # Create session
        session = self.client.create_session(
            schema_path=schema_path,
            name=f"{app_name}-django-models"
        )
        
        self.session_id = session['sessionId']
        os.remove(schema_path)  # Clean up
        
        return session

    def _get_typescript_type(self, field):
        """Convert Django field types to TypeScript types."""
        field_type = type(field).__name__
        
        type_mapping = {
            'CharField': 'string',
            'TextField': 'string',
            'EmailField': 'string',
            'URLField': 'string',
            'IntegerField': 'number',
            'FloatField': 'number',
            'DecimalField': 'number',
            'BooleanField': 'boolean',
            'DateField': 'Date',
            'DateTimeField': 'Date',
            'ForeignKey': 'number',  # Assuming ID reference
            'OneToOneField': 'number',
            'ManyToManyField': 'number[]',
        }
        
        return type_mapping.get(field_type, 'any')

    def populate_test_data(self, model_name: str, count: int = 50):
        """Generate and return test data for a specific model."""
        if not self.session_id:
            raise Exception("No active session. Create a session first.")
        
        endpoint = model_name.lower() + 's'  # Simple pluralization
        return self.client.generate_data(endpoint, self.session_id, count=count)

# Django management command
class Command(BaseCommand):
    help = 'Generate test data using Monody'

    def add_arguments(self, parser):
        parser.add_argument('app_name', type=str, help='Django app name')
        parser.add_argument('--count', type=int, default=50, help='Number of records to generate')

    def handle(self, *args, **options):
        integration = MonodyDjangoIntegration()
        
        try:
            # Create session from Django models
            session = integration.create_session_from_models(options['app_name'])
            self.stdout.write(f"Created session: {session['sessionId']}")
            
            # Get all models from the app
            app_config = apps.get_app_config(options['app_name'])
            models = app_config.get_models()
            
            for model in models:
                model_name = model.__name__
                data = integration.populate_test_data(model_name, options['count'])
                
                # Save to fixture file
                fixture_path = f"fixtures/{model_name.lower()}_test_data.json"
                os.makedirs('fixtures', exist_ok=True)
                
                with open(fixture_path, 'w') as f:
                    json.dump(data, f, indent=2, default=str)
                
                self.stdout.write(
                    self.style.SUCCESS(
                        f"Generated {len(data)} {model_name} records -> {fixture_path}"
                    )
                )
                
        except Exception as e:
            self.stdout.write(self.style.ERROR(f"Error: {e}"))

curl -X POST https://api.monody.dev/sessions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "schema=@interface.ts" \
  -F "name=my-project"

curl "https://api.monody.dev/users?sessionId=mf_abc123xyz&count=10" \
  -H "Authorization: Bearer YOUR_API_KEY"