// Create with current date
await db.createDocument('events', {
  'name': 'Product Launch',
  'date': DateTime.now().toIso8601String(),
});

// Parse date from document
final event = await db.getDocument('events', 'event_123');
final date = DateTime.parse(event['date']);
print(date.toString());

// Create with current date
db.CreateDocument(ctx, "events", map[string]any{
    "name": "Product Launch",
    "date": time.Now().Format(time.RFC3339),
})

// Parse date from document
event, _ := db.GetDocument(ctx, "events", "event_123")
date, _ := time.Parse(time.RFC3339, event["date"].(string))

from datetime import datetime

# Create with current date
db.create_document("events", {
    "name": "Product Launch",
    "date": datetime.now().isoformat()
})

# Parse date from document
event = db.get_document("events", "event_123")
date = datetime.fromisoformat(event['date'])

class User {
  final String name;
  final String email;
  final int age;

  User({required this.name, required this.email, required this.age}) {
    // Validate in constructor
    if (name.isEmpty || name.length > 100) {
      throw ArgumentError('Name must be between 1 and 100 characters');
    }
    if (!email.contains('@')) {
      throw ArgumentError('Invalid email format');
    }
    if (age < 0 || age > 150) {
      throw ArgumentError('Age must be between 0 and 150');
    }
  }

  Map<String, dynamic> toJson() {
    return {'name': name, 'email': email, 'age': age};
  }
}

// Use validated model
try {
  final user = User(name: 'Alice', email: '[email protected]', age: 28);
  await db.createDocument('users', user.toJson());
} catch (e) {
  print('Validation error: $e');
}

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age"`
}

func (u *User) Validate() error {
    if len(u.Name) == 0 || len(u.Name) > 100 {
        return errors.New("name must be between 1 and 100 characters")
    }
    if !strings.Contains(u.Email, "@") {
        return errors.New("invalid email format")
    }
    if u.Age < 0 || u.Age > 150 {
        return errors.New("age must be between 0 and 150")
    }
    return nil
}

// Validate before creating
user := &User{Name: "Alice", Email: "[email protected]", Age: 28}
if err := user.Validate(); err != nil {
    return err
}
db.CreateDocument(ctx, "users", user)

def validate_user(data):
    required = ['name', 'email', 'age']
    for field in required:
        if field not in data:
            raise ValueError(f"Missing required field: {field}")

    if not data['name'] or len(data['name']) > 100:
        raise ValueError("Name must be between 1 and 100 characters")

    if '@' not in data['email']:
        raise ValueError("Invalid email format")

    if not isinstance(data['age'], int) or data['age'] < 0 or data['age'] > 150:
        raise ValueError("Age must be between 0 and 150")

    return True

# Validate before creating
user_data = {
    "name": "Alice",
    "email": "[email protected]",
    "age": 28
}

validate_user(user_data)
db.create_document("users", user_data)

def main():
    data = req.json()

    # Validate required fields
    required = ['name', 'email', 'age']
    for field in required:
        if field not in data:
            return {"error": f"Missing required field: {field}"}, 400

    # Validate data types and constraints
    if not isinstance(data['age'], int) or data['age'] < 0:
        return {"error": "Age must be a positive integer"}, 400

    if '@' not in data['email']:
        return {"error": "Invalid email format"}, 400

    # Create document after validation
    user = db.create_document("users", data)
    return {"user": user}