💦Darturbation💦: Advanced Mock Data Generator for Dart & Flutter #

Darturbation is an advanced mock data generator for Dart and Flutter, focusing on context-aware and behavioral pattern generation. It's designed to overcome the limitations of traditional faker libraries by providing data that is not only random but also realistic and logically interconnected.

Core Value Proposition #

1. Indonesian-First Approach #

Darturbation is built with a strong focus on Indonesian cultural context, enabling the generation of highly authentic and relevant data:

• Authentic Indonesian Names: Generate realistic Indonesian names (e.g., Budi Santoso, Siti Rahayu).
• Real Addresses: Produce addresses with real Indonesian cities, provinces, and common street names.
• Indonesian Phone Numbers: Generate phone numbers formatted for Indonesia (+62).
• Cultural Context Awareness: Data generation considers local nuances and patterns.

2. Context-Aware Generation #

Beyond simple randomness, Darturbation ensures data is logically interconnected:

• Related Data: User emails match names, order dates align with user registration.
• Behavioral Consistency: Users with high income are more likely to purchase expensive products.
• Temporal Relationships: Order dates and review dates reflect realistic timelines.
• Geographic Correlation: Addresses correlate with cities and provinces.

3. Behavioral Pattern Simulation #

Simulate complex real-world behaviors and trends:

• Seasonal Trends: Model seasonal boosts (e.g., Ramadan, Christmas) and slumps.
• User Behavior Modeling: Differentiate between power users, casual users, and inactive users.
• Realistic Distributions: Apply principles like the Pareto principle for sales data.
• Time-Based Patterns: Simulate payday effects and weekend activity.

Installation #

Add Darturbation to your pubspec.yaml file:

dependencies:
  darturbation: ^1.0.0 # Use the latest version
  # Other dependencies

Then, run dart pub get in your terminal.

Basic Usage #

Import the package:

import 'package:darturbation/darturbation.dart';

Generating a Single User #

final user = Darturbation.user();
print('Generated User: ${user.firstName} ${user.lastName}, Email: ${user.email}');

Generating Multiple Products #

final products = Darturbation.products(count: 5);
for (var product in products) {
  print('Product: ${product.name}, Price: ${product.price}');
}

Generating Data from a Custom Schema #

final customSchema = {
  'id': int,
  'first_name': String,
  'last_name': String,
  'email_address': String,
  'is_active': bool,
  'balance': double,
  'registration_date': DateTime,
};

final generatedData = Darturbation.fromSchema(schema: customSchema, count: 3);
print('\nGenerated Data from Schema:');
generatedData.forEach(print);

Advanced Usage: E-commerce Scenario #

Darturbation's EcommerceScenario allows you to generate interconnected datasets for users, products, orders, and reviews.

final ecommerceScenario = Darturbation.scenario('indonesian_ecommerce')
  .users(100, region: 'jakarta')
  .products(50, categories: ['electronics', 'fashion'])
  .orders(seasonality: 'ramadan_boost')
  .reviews();

final data = ecommerceScenario.generate();

print('\nE-commerce Scenario Data:');
print('Users: ${data['users'].length}');
print('Products: ${data['products'].length}');
print('Orders: ${data['orders'].length}');
print('Reviews: ${data['reviews'].length}');

// Access specific data
print('\nSample Order:');
print(data['orders'].first.toJson());

Streaming Data Generation (for Large Datasets) #

For very large datasets, you can use the streaming API to generate data incrementally, reducing memory footprint.

import 'package:darturbation/darturbation.dart';

void main() async {
  print('--- Streaming Generated Data (5 users, 5 products, 5 orders, 5 reviews) ---');
  final streamingData = Darturbation.scenario('indonesian_ecommerce').generateStream(
    userCount: 5,
    productCount: 5,
    orderCount: 5,
    reviewCount: 5,
  );

  await for (final dataItem in streamingData) {
    print('Generated ${dataItem['type']}: ${dataItem['data']}');
  }
}

Exporting Data #

Darturbation supports various export formats.

Exporting to JSON #

final usersToExport = Darturbation.users(count: 2);
final jsonOutput = Darturbation.export(usersToExport, to: 'json');
print('\nJSON Export:');
print(jsonOutput);

Exporting to CSV #

final productsToExport = Darturbation.products(count: 2);
final csvOutput = Darturbation.export(productsToExport, to: 'csv');
print('\nCSV Export:');
print(csvOutput);

Exporting to SQL INSERT Statements #

final orders = Darturbation.orders(count: 2, fromUsers: Darturbation.users(count: 2), withProducts: Darturbation.products(count: 2));
final sqlOutput = Darturbation.export(orders, to: 'sql', tableName: 'ecommerce_orders');
print('\nSQL Export:');
print(sqlOutput);

API Reference (Key Classes & Methods) #

Darturbation (Static Class) #

• static User user(): Generates a single User object.
• static List<User> users({int count = 10}): Generates a list of User objects.
• static Product product(): Generates a single Product object.
• static List<Product> products({int count = 10}): Generates a list of Product objects.
• static Order order({required User user, required List<Product> withProducts}): Generates a single Order object.
• static List<Order> orders({int count = 10, required List<User> fromUsers, required List<Product> withProducts}): Generates a list of Order objects.
• static List<Map<String, dynamic>> fromSchema({required Map<String, Type> schema, int count = 10}): Generates data based on a provided schema.
• static String export<T>(List<T> data, {required String to, String tableName = 'data'}): Exports a list of data to specified format (json, csv, sql).
• static EcommerceScenario scenario(String type): Entry point for scenario-based generation.
• static Stream<User> streamUsers({int count = 10}): Streams User objects.
• static Stream<Product> streamProducts({int count = 10}): Streams Product objects.
• static Stream<Order> streamOrders({required List<User> users, required List<Product> products, int count = 10}): Streams Order objects.
• static Stream<Review> streamReviews({required List<User> users, required List<Product> products, required List<Order> orders, int count = 10}): Streams Review objects.
• static int randomInt(int min, int max): Generates a random integer.
• static double randomDouble(double min, double max): Generates a random double.
• static T randomChoice<T>(List<T> items): Selects a random item from a list.
• static bool randomBool([double probability = 0.5]): Generates a random boolean.
• static String generateId(): Generates a UUID-like ID.

EcommerceScenario #

• EcommerceScenario users(int count, {String? region}): Configures user generation.
• EcommerceScenario products(int count, {List<String>? categories}): Configures product generation.
• EcommerceScenario orders({String? seasonality}): Configures order generation.
• EcommerceScenario reviews(): Configures review generation.
• Map<String, dynamic> generate(): Generates all configured data as lists.
• Map<String, Stream<dynamic>> generateStream(...): Generates all configured data as streams.

Models (User, Product, Order, Review) #

These classes represent the generated data entities. Each includes a toJson() method for serialization.

Contributing #

We welcome contributions! Please see our CONTRIBUTING.md for details.

License #

This project is licensed under the MIT License - see the LICENSE file for details.