Vania

https://pub.dev/documentation/vania/latest
Admin
Vania is a robust backend framework for Dart, designed to build high-performance web applications...
Tokens:84,003
Snippets:487
Trust Score:9.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Setup Database and Seeders (Dart)

Source: https://pub.dev/documentation/vania/latest/database/SeederRunner/setup

The `setup` method configures the default database connection using provided parameters and then iterates through a list of seeders to populate the database. It includes error handling for connection issues and seeder execution, reporting the time taken for each seeder.

```dart
Future<void> setup({
  required Map<String, dynamic> database,
  required List<Seeder> seeders,
}) async {
  if (database['default'] == null) {
    stderr.write('❌ Database config not valid');
    exit(1);
  }
  try {
    ConnectionManager().defaultConnection = database['default'];
    Map<String, dynamic> connections = database['connections'];
    await ConnectionManager().connect(
      _config(connections[ConnectionManager().defaultConnection]),
      database['default'],
    );
  } catch (e) {
    stderr.write(e);
    exit(1);
  } finally {
    for (Seeder seeder in seeders) {
      final stopwatch = Stopwatch()..start();
      try {
        await seeder.run();
        stopwatch.stop();
        stderr.writeln(
            ' Seeder ${toSnakeCase(seeder.runtimeType.toString())} executed ....................................\x1B[32m ${stopwatch.elapsedMilliseconds}ms DONE\x1B[0m');
      } on QueryException catch (e) {
        stopwatch.stop();
        stderr.write(e.cause);
        await ConnectionManager().connection(database['default'])!.close();
        exit(1);
      }
    }
    await ConnectionManager().connection(database['default'])!.close();
    stderr
        .write('\x1B[32m All database seeders executed successfully \x1B[0m');
    exit(0);
  }
}
```

--------------------------------

### Setup Database Connection and Configuration (Dart)

Source: https://pub.dev/documentation/vania/latest/migration/MigrationConnection/setup

The setup method initializes the database connection by processing a configuration map. It establishes a default connection, retrieves connection details, and sets up the necessary database driver and adapter. Includes error handling for connection issues and invalid arguments.

```dart
@override
Future<void> setup(Map<String, dynamic> databaseConfig) async {
  try {
    final connectionManager = ConnectionManager();

    connectionManager.defaultConnection = databaseConfig['default'];

    Map<String, dynamic> connections = databaseConfig['connections'];

    _driver = databaseConfig['default'];
    await connectionManager.connect(
      _createDBConfig(connections[_driver]),
      _driver!,
    );

    _dbConnection = connectionManager.connection(_driver);

    if (_dbConnection == null) {
      stderr.writeln('A database must be specified.');
      exit(1);
    }

    _adapter = _createAdapter(_driver!);

    String migrationSql = _adapter!.getMigrationsTableSql();
    await _dbConnection!.execute(migrationSql);
  } on InvalidArgumentException catch (e) {
    stderr.writeln(e.message);
    exit(1);
  } catch (e) {
    stderr.write(e.toString());
    exit(1);
  }
}
```

--------------------------------

### Start Vania Development Server

Source: https://pub.dev/documentation/vania/latest/index

Starts the Vania development server for the current project. This allows for live reloading and easy testing during development. The `--vm` flag can be used to enable the VM service.

```bash
vania serve
```

--------------------------------

### Install Vania CLI

Source: https://pub.dev/documentation/vania/latest/index

Installs the Vania CLI tool globally using Dart's package manager. This tool is essential for creating and managing Vania projects.

```bash
dart pub global activate vania_cli
```

--------------------------------

### Dart StartWith Class - Constructor and Properties

Source: https://pub.dev/documentation/vania/latest/http_request/StartWith-class

Defines the constructor and properties for the Dart StartWith class. The constructor requires a 'start' string and optionally accepts a 'message'. Properties include 'errorMessage', 'hashCode', 'message', 'runtimeType', and 'start'.

```dart
class StartWith extends ValidationRule {
  final String start;
  final String? message;

  StartWith.new({required this.start, this.message});

  String get errorMessage => ""; // Placeholder, actual implementation might differ
  // Other inherited properties like hashCode, runtimeType are omitted for brevity
}
```

--------------------------------

### SeederRunner Setup Method

Source: https://pub.dev/documentation/vania/latest/database/SeederRunner-class

Sets up the SeederRunner by providing the database configuration and a list of seeders to run. This method is asynchronous.

```dart
setup({required Map<String, dynamic> database, required List<Seeder> seeders}) → Future<void>
```

--------------------------------

### Setup Database Configuration

Source: https://pub.dev/documentation/vania/latest/migration/MigrationConnection-class

Shows how to set up the database configuration for the MigrationConnection. This method takes a map of string keys to dynamic values, representing database credentials and settings.

```dart
await connection.setup({
  'username': 'db_user',
  'password': 'db_password',
  'host': 'localhost',
  'port': 5432,
  'database': 'my_database'
});
```

--------------------------------

### Dart Vania Framework Route and Middleware Setup

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Demonstrates how to set up routes and apply middleware in the Vania Framework using Dart. Shows global middleware application, route-specific middleware, and middleware grouping. Dependencies include Vania's `Router`, `Response`, and various custom middleware classes.

```dart
// Apply middleware to routes
void setupMiddleware() {
  // Global middleware (applied to all routes)
  Router.use([
    CorsMiddleware(),
    LoggingMiddleware(),
  ]);

  // Route-specific middleware
  Router.get('/protected', () {
    return Response.json({'message': 'Protected resource'});
  }).middleware([AuthMiddleware()]);

  // Group middleware
  Router.group(() {
    Router.get('/users', () => Response.json({}));
    Router.post('/posts', () => Response.json({}));
  }, middleware: [
    AuthMiddleware(),
    RateLimitMiddleware(maxRequests: 100),
  ]);
}
```

--------------------------------

### Initialize Application with IoC Container - Dart

Source: https://pub.dev/documentation/vania/latest/application/Application/initialize

The `initialize` method sets up the application by registering `RequestHandler` and `SessionManager` in the IoC container. It validates the `APP_KEY` environment variable and starts the `BaseHttpServer`. Dependencies include the `IoCContainer` and `BaseHttpServer` classes. It takes a required `config` map and optional `args` list.

```dart
Future<void> initialize({
  required Map<String, dynamic> config,
  List<String> args = const []
}) async {
  IoCContainer().register<RequestHandler>(() => RequestHandler());
  IoCContainer()
      .register<SessionManager>(() => SessionManager(), singleton: true);
  if (env('APP_KEY') == '' || env('APP_KEY') == null) {
    throw Exception('Key not found');
  }

  _server = BaseHttpServer(config: config, args: args);
  _server.startServer();
}
```

--------------------------------

### Get and Set Value

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Sets a new value for a key and returns the old value.

```APIDOC
## POST /getSet

### Description
Sets a new value for a key and returns the old value that was associated with the key.

### Method
POST

### Endpoint
/getSet

### Parameters
#### Request Body
- **key** (K) - Required - The key to set the value for.
- **value** (V) - Required - The new value to set.

### Request Example
```json
{
  "key": "mykey",
  "value": "new_value"
}
```

### Response
#### Success Response (200)
- **oldValue** (V?) - The old value associated with the key, or null if the key did not exist.

#### Response Example
```json
{
  "oldValue": "old_value"
}
```
```

--------------------------------

### Get Keys Matching Pattern

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Retrieves a list of keys that match a given pattern.

```APIDOC
## GET /keys

### Description
Retrieves a list of keys that match the provided `pattern`.

### Method
GET

### Endpoint
/keys

### Parameters
#### Query Parameters
- **pattern** (String) - Required - The pattern to match keys against (e.g., 'user:*').

### Response
#### Success Response (200)
- **keys** (List<String>) - A list of keys matching the pattern.

#### Response Example
```json
{
  "keys": ["user:1", "user:2", "user:3"]
}
```
```

--------------------------------

### Dart Timeout Method Usage Examples

Source: https://pub.dev/documentation/vania/latest/migration/TableDefinition/timeout

Demonstrates various scenarios of using the `timeout` method on Futures. It covers successful completion within the time limit, handling timeouts with custom callbacks, and catching `TimeoutException`.

```dart
void main() async {
  var result = 
      await waitTask("completed").timeout(const Duration(seconds: 10));
  print(result); // Prints "completed" after 5 seconds.

  result = await waitTask("completed")
      .timeout(const Duration(seconds: 1), onTimeout: () => "timeout");
  print(result); // Prints "timeout" after 1 second.

  result = await waitTask("first").timeout(const Duration(seconds: 2),
      onTimeout: () => waitTask("second"));
  print(result); // Prints "second" after 7 seconds.

  try {
    await waitTask("completed").timeout(const Duration(seconds: 2));
  } on TimeoutException {
    print("throws"); // Prints "throws" after 2 seconds.
  }

  var printFuture = waitPrint();
  await printFuture.timeout(const Duration(seconds: 2), onTimeout: () {
    print("timeout"); // Prints "timeout" after 2 seconds.
  });
  await printFuture; // Prints "printed" after additional 3 seconds.

  try {
    await waitThrow("error").timeout(const Duration(seconds: 2));
  } on TimeoutException {
    print("throws"); // Prints "throws" after 2 seconds.
  }
  // StateError is ignored
}

/// Returns [string] after five seconds.
Future<String> waitTask(String string) async {
  await Future.delayed(const Duration(seconds: 5));
  return string;
}

/// Prints "printed" after five seconds.
Future<void> waitPrint() async {
  await Future.delayed(const Duration(seconds: 5));
  print("printed");
}
/// Throws a [StateError] with [message] after five seconds.
Future<void> waitThrow(String message) async {
  await Future.delayed(const Duration(seconds: 5));
  throw Exception(message);
}
```

--------------------------------

### Execute Database Migrations (Dart)

Source: https://pub.dev/documentation/vania/latest/migration/MigrationRunner/run

The `run` method in Dart orchestrates database migration processes. It checks for an active database connection and then executes migrations based on provided command-line arguments. Supported arguments include '--fresh' to apply all migrations, '--install' to initialize, '--refresh' to reset and apply, '--reset' to clear all migrations, and '--rollback' to revert migrations with optional step and batch control. If no arguments are given, it applies all pending migrations sequentially.

```dart
Future<void> run(List<String> args) async {
  if (MigrationConnection().connection == null) {
    stderr.writeln(
      'Database connection not established',
    );
    exit(1);
  }
  if (args.contains('--fresh')) {
    await _fresh(_migrations.values.toList());
  } else if (args.contains('--install')) {
    await _install();
  } else if (args.contains('--refresh')) {
    await _refresh(_migrations);
  } else if (args.contains('--reset')) {
    await _reset(_migrations);
  } else if (args.contains('--rollback')) {
    int? steps = args.contains('--steps')
        ? int.tryParse(args[args.indexOf('--steps') + 1])
        : null;
    int? batch = args.contains('--batch')
        ? int.tryParse(args[args.indexOf('--batch') + 1])
        : null;
    await _rollback(_migrations, steps: steps, batch: batch);
  } else {
    for (final migration in _migrations.values) {
      await _runUp(migration.migrationName, migration.up);
    }
    stderr.writeln('✅ All migrations executed successfully!');
  }
}
```

--------------------------------

### Get Value

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Retrieves the value associated with a key.

```APIDOC
## GET /get

### Description
Retrieves the value associated with a key.

### Method
GET

### Endpoint
/get

### Parameters
#### Query Parameters
- **key** (K) - Required - The key whose value needs to be retrieved.

### Response
#### Success Response (200)
- **value** (V?) - The value associated with the key, or null if the key does not exist.

#### Response Example
```json
{
  "value": "some_value"
}
```
```

--------------------------------

### Create Redirect HTTP Responses in Vania

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Implement HTTP redirects to guide users to a different URL. Supports both temporary (302) and permanent (301) redirects, useful for URL changes or post-action navigation.

```dart
import 'package:vania/vania.dart';

// Redirect response
Router.get('/old-url', () => Response.redirect('/new-url'));

Router.post('/login', (Request req) async {
  // ... authentication logic
  return Response.redirect('/dashboard');
});
```

--------------------------------

### PSUBSCRIBE Method Implementation - Dart

Source: https://pub.dev/documentation/vania/latest/vania/CommandsClient/psubscribe

Implements the Redis PSUBSCRIBE command to subscribe to messages matching a pattern. It sends the PSUBSCRIBE command to the Redis connection, then processes the incoming stream of messages, filtering for valid responses and decoding the message payload. Dependencies include the Redis connection object and a value codec for message decoding.

```dart
@override
Stream<V> psubscribe(String pattern) {
  _connection.sendCommand(Resp(['PSUBSCRIBE', pattern]));
  return _connection.stream
      .map((event) => event?.arrayValue)
      .where((event) => event != null)
      .map((event) => event!)
      .where((e) => e.length == 4) // length == 3 is subscribed notification
      .map((event) => valueCodec.decode(event.last));
}
```

--------------------------------

### Dart Middleware for Request Logging in Vania

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Implements a logging middleware in Dart for the Vania Framework. It logs the start time, HTTP method, and path of incoming requests, and logs the response status code and duration after the request is processed. Dependencies include Vania's `Middleware`, `Request`, and `Response` classes.

```dart
import 'package:vania/vania.dart';

// Logging middleware
class LoggingMiddleware extends Middleware {
  @override
  Future<Response?> handle(Request req) async {
    final startTime = DateTime.now();

    print('[${startTime.toIso8601String()}] ${req.method} ${req.path}');

    // Continue to next middleware/handler
    final response = await next?.handle(req);

    final duration = DateTime.now().difference(startTime);
    print('[${req.method}] ${req.path} - ${response?.httpStatusCode ?? 200} (${duration.inMilliseconds}ms)');

    return response;
  }
}
```

--------------------------------

### Get Value and Delete

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Retrieves the value associated with a key and then deletes the key.

```APIDOC
## GET /getdel

### Description
Retrieves the value associated with a key and then deletes the key.

### Method
GET

### Endpoint
/getdel

### Parameters
#### Query Parameters
- **key** (K) - Required - The key whose value needs to be retrieved and deleted.

### Response
#### Success Response (200)
- **value** (V?) - The value associated with the key before deletion, or null if the key did not exist.

#### Response Example
```json
{
  "value": "some_value"
}
```
```

--------------------------------

### Dart QueryBuilder: Chunk Processing and Existence Check

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Demonstrates how to process large datasets in chunks to manage memory efficiently. It also shows a basic example of how to check for the existence of records that meet certain criteria.

```dart
import 'package:vania/vania.dart';

// Chunk processing (for large datasets)
await DB.table('users').chunk(100, (List<Map<String, dynamic>> users) {
  for (var user in users) {
    print('Processing user: ${user['name']}');
  }
});

// Check existence
// Example: Check if any user with status 'active' exists
final exists = await DB.table('users').where('status', '=', 'active').exists();
print('Active users exist: $exists');
```

--------------------------------

### Example Usage of toFixed Method

Source: https://pub.dev/documentation/vania/latest/vania/NumberExtension/toFixed

Demonstrates how to use the toFixed method in Dart. It shows rounding of a floating-point number, an integer, and a negative number to a specified number of decimal places. The output is printed to the console.

```dart
var number = 123.4567;
var rounded = number.toFixed(2);
print(rounded); // Outputs: 123.46

var integer = 123;
var roundedInt = integer.toFixed(0);
print(roundedInt); // Outputs: 123

var negative = -123.456;
var roundedNeg = negative.toFixed(3);
print(roundedNeg); // Outputs: -123.456
```

--------------------------------

### Dart Resource Static Method Implementation

Source: https://pub.dev/documentation/vania/latest/route/Router/resource

This Dart code defines a static method `resource` that registers multiple routes for a given controller. It handles GET, POST, PUT, and DELETE requests for index, create, store, show, edit, update, and destroy actions. It supports optional middleware, domain, and prefix configurations, and allows for regular expression filtering on route parameters like 'id'.

```dart
static void resource(
  String path,
  dynamic controller, {
  String? prefix,
  List<Middleware>? middleware,
  String? domain,
  String regex = r'\d+(.\d+)?',
}) {
  Router.get(path, controller.index)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix);

  Router.get("$path/create", controller.create)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix);

  Router.post(path, controller.store)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix);

  Router.get("$path/{id}", controller.show)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix)
      .where('id', regex);

  Router.get("$path/{id}/edit", controller.edit)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix)
      .where('id', regex);

  Router.put("$path/{id}", controller.update)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix)
      .where('id', regex);

  Router.delete("$path/{id}", controller.destroy)
      .middleware(middleware)
      .domain(domain)
      .prefix(prefix)
      .where('id', regex);
}
```

--------------------------------

### Dart DateTime Formatting Example

Source: https://pub.dev/documentation/vania/latest/vania/DateTimeExtension/format

Demonstrates how to use the format() method on a Dart DateTime object to get a human-readable string representation. The method returns a string in 'YYYY-MM-DD HH:MM:SS' format.

```dart
var now = DateTime.now();
var formatted = now.format();
print(formatted); // Outputs: '2023-08-03 14:25:30' (varies based on current time)
```

--------------------------------

### Dart Get Method Implementation

Source: https://pub.dev/documentation/vania/latest/orm_model/Model/get

Implements the 'get' method to fetch data, manage soft deletes by filtering out deleted records, and remove specified hidden columns from the results. It also loads associated relations. This method is asynchronous and returns a Future list of maps.

```dart
@override
Future<List<Map<String, dynamic>>> get([
  List<String> columns = const ['*'],
]) async {
  try {
    if (softDeletes) {
      whereNull(deletedAt);
    }
    List<Map<String, dynamic>> result = await super.get(columns);

    for (Map<String, dynamic> map in result) {
      map.removeWhere((key, _) => hidden.contains(key));
    }

    return _loadRelations(result);
  } catch (e) {
    throw Exception(e);
  }
}
```

--------------------------------

### Auto Increment Start Value

Source: https://pub.dev/documentation/vania/latest/migration/TableDefinition-class

Sets the starting value for an auto-incrementing field in the table definition. This method is part of the TableDefinition builder pattern.

```dart
autoIncrement(int startValue) → TableDefinition
```

--------------------------------

### Cache PUT Example Usage in Dart

Source: https://pub.dev/documentation/vania/latest/vania/Cache/put

This Dart snippet demonstrates how to use the `Cache.put` static method. It shows two examples: storing a value with the default duration and storing a value with a specified custom duration. These examples are intended for use within an environment where the `Cache` class and its associated `Duration` type are available.

```dart
await Cache.put('foo', 'bar');
await Cache.put('foo', 'bar', duration: Duration(hours: 24));
```

--------------------------------

### Route Constructor and Properties (Dart)

Source: https://pub.dev/documentation/vania/latest/route/Route-class

Demonstrates the instantiation of the Route class using Route.new() and showcases its properties like hashCode, prefix, and runtimeType. These properties provide information about the route's state and type.

```dart
// Constructor
var route = Route.new();

// Properties
int hashCode = route.hashCode;
String? prefix = route.prefix;
Type runtimeType = route.runtimeType;
```

--------------------------------

### Retrieve Environment Value with Type Casting (Dart)

Source: https://pub.dev/documentation/vania/latest/vania/Env/get

Demonstrates how to use the `get<T>` static method to retrieve environment variables. It supports providing a default value and specifying the expected return type for automatic conversion.

```Dart
Evn.get('APP_KEY');
Evn.get('APP_KEY', 'Default Value');
Evn.get<int>('PORT', 3000);
Evn.get<num>('PORT', 3000);
Evn.get<String>('APP_KEY');
```

```Dart
static T get<T>(String key, [dynamic defaultValue]) {
  dynamic value = Env().env[key];
  value ??= Platform.environment[key];
  value ??= defaultValue;
  if (T.toString() == 'int') {
    return int.parse(value.toString()) as T;
  }

  if (T.toString() == 'double') {
    return double.parse(value.toString()) as T;
  }

  if (T.toString() == 'num') {
    return num.parse(value.toString()) as T;
  }

  if (T.toString() == 'bool') {
    return bool.parse(value.toString()) as T;
  }

  return value;
}
```

--------------------------------

### Initialize MigrationConnection

Source: https://pub.dev/documentation/vania/latest/migration/MigrationConnection-class

Demonstrates the creation of a new MigrationConnection instance using its default constructor.

```dart
var connection = MigrationConnection.new();
```

--------------------------------

### TableDefinition Constructor

Source: https://pub.dev/documentation/vania/latest/migration/TableDefinition-class

Initializes a new TableDefinition instance. It requires a table name and a function to create the table. Optional parameters include a database connection and an adapter.

```dart
TableDefinition.new(String _tableName, Future<void> _createFunction(), {MigrationConnection? connection, DatabaseAdapterInterface? adapter})
```

--------------------------------

### Example Usage of whenComplete in Dart

Source: https://pub.dev/documentation/vania/latest/migration/TableDefinition/whenComplete

Demonstrates how to use the whenComplete method to execute a task after a Future completes. The provided example shows a `main` function awaiting a `waitTask` Future and then executing a print statement upon its completion. This illustrates the asynchronous 'finally' behavior.

```dart
void main() async {
  var value =
      await waitTask().whenComplete(() => print('do something here'));
  // Prints "do something here" after waitTask() completed.
  print(value); // Prints "done"
}

Future<String> waitTask() {
  Future.delayed(const Duration(seconds: 5));
  return Future.value('done');
}
// Outputs: 'do some work here' after waitTask is completed.

```

--------------------------------

### Dart hashCode Implementation Example

Source: https://pub.dev/documentation/vania/latest/http_request/GreaterThan/hashCode

An example of how to override the hashCode getter in Dart. It demonstrates that if the equality operator (==) is overridden, the hashCode must also be overridden to reflect the object's state, ensuring consistency for hash-based collections like Sets and Maps.

```dart
@override
int get hashCode => compare.hashCode;
```

--------------------------------

### Serve File Downloads with Vania

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Generate HTTP responses that trigger file downloads for the client. Reads file content as bytes and specifies the download filename.

```dart
import 'package:vania/vania.dart';
import 'dart:io';

// File download
Router.get('/download/report', () async {
  final bytes = await File('reports/monthly.pdf').readAsBytes();
  return Response.download('monthly_report.pdf', bytes);
});
```

--------------------------------

### Get Multiple Values

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Retrieves the values associated with multiple keys.

```APIDOC
## POST /mGet

### Description
Retrieves the values associated with multiple keys in a single request.

### Method
POST

### Endpoint
/mGet

### Parameters
#### Request Body
- **keys** (List<K>) - Required - A list of keys whose values need to be retrieved.

### Request Example
```json
{
  "keys": ["key1", "key2", "key3"]
}
```

### Response
#### Success Response (200)
- **values** (List<V>) - A list of values corresponding to the requested keys. The order of values matches the order of keys.

#### Response Example
```json
{
  "values": ["value1", "value2", null]
}
```
```

--------------------------------

### Dart Post Controller for Blog Posts

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Handles operations for blog posts, including listing published posts with pagination and author details, and creating new posts with validation. It leverages the Vania framework for routing, authentication, and data manipulation.

```dart
// Post controller with relationships
class PostController extends Controller {
  Future<Response> index(Request req) async {
    final posts = await Post()
      .include('author')
      .where('status', '=', 'published')
      .orderByDesc('published_at')
      .paginate(perPage: 20);

    return Response.json(posts);
  }

  Future<Response> store(Request req) async {
    await req.validate({
      'title': 'required|string|max:255',
      'content': 'required|string',
      'status': 'required|in:draft,published',
    });

    final user = Auth().user();

    final post = await Post().create({
      'title': req.input('title'),
      'content': req.input('content'),
      'slug': generateSlug(req.input('title')),
      'user_id': user['id'],
      'status': req.input('status', 'draft'),
    });

    return Response.json({'post': post}, 201);
  }
}

// Resource controller (RESTful)
Router.resource('/posts', PostController());
// Generates: GET /posts, POST /posts, GET /posts/{id}, PUT /posts/{id}, DELETE /posts/{id}

```

--------------------------------

### Create New Vania Project

Source: https://pub.dev/documentation/vania/latest/index

Creates a new Vania project with a specified name. This command scaffolds a new application structure, ready for development.

```bash
vania create blog
```

--------------------------------

### Get Range

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Retrieves a sub-string of the string value stored at a key.

```APIDOC
## GET /getRange

### Description
Retrieves a sub-string of the string value stored at a key, between `start` and `end` offsets.

### Method
GET

### Endpoint
/getRange

### Parameters
#### Query Parameters
- **key** (K) - Required - The key whose value's sub-string needs to be retrieved.
- **start** (int) - Required - The starting offset.
- **end** (int) - Required - The ending offset.

### Response
#### Success Response (200)
- **value** (V?) - The sub-string value, or null if the key does not exist.

#### Response Example
```json
{
  "value": "sub_string"
}
```
```

--------------------------------

### Send Welcome Email with Vania Dart

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Sends a welcome email to a newly registered user, including a verification link. This involves creating a WelcomeEmail class extending Mailable and then calling its send() method after user registration and token generation. It supports both HTML and plain text content.

```dart
import 'package:vania/vania.dart';

// Basic email class
class WelcomeEmail extends Mailable {
  final String userName;
  final String verificationLink;

  WelcomeEmail(this.userName, this.verificationLink);

  @override
  Envelope envelope() {
    return Envelope(
      from: Address('noreply@example.com', 'MyApp'),
      to: [Address(userName, userName)],
      subject: 'Welcome to MyApp - Please Verify Your Email',
    );
  }

  @override
  Content? content() {
    return Content(
      html: '''
        <html>
          <body>
            <h1>Welcome, $userName!</h1>
            <p>Thank you for registering with MyApp.</p>
            <p>Please verify your email address by clicking the link below:</p>
            <a href="$verificationLink">Verify Email</a>
            <p>If you didn't create this account, please ignore this email.</p>
          </body>
        </html>
      ''',
      text: '''
        Welcome, $userName!

        Thank you for registering with MyApp.

        Please verify your email address by visiting:
        $verificationLink

        If you didn't create this account, please ignore this email.
      ''',
    );
  }

  @override
  List<Attachment>? attachments() {
    return null; // No attachments
  }
}

// Send welcome email
Router.post('/register', (Request req) async {
  await req.validate({
    'name': 'required|string',
    'email': 'required|email|unique:users,email',
    'password': 'required|min:8',
  });

  final user = await DB.table('users').insertGetId({
    'name': req.input('name'),
    'email': req.input('email'),
    'password': Hash.make(req.input('password')),
    'created_at': DateTime.now().toIso8601String(),
  });

  final verificationToken = Hash.make('${user}_${DateTime.now().millisecondsSinceEpoch}');
  final verificationLink = 'https://example.com/verify?token=$verificationToken';

  // Send email
  await WelcomeEmail(req.input('email'), verificationLink).send();

  return Response.json({
    'message': 'Registration successful. Please check your email.',
    'user_id': user,
  });
});
```

--------------------------------

### Set Range

Source: https://pub.dev/documentation/vania/latest/vania/KeysCommands-class

Overwrites part of a string at `key` starting from the specified `offset`.

```APIDOC
## POST /setRange

### Description
Overwrites part of a string at `key` starting from the specified `offset` with the provided `value`. If the key does not exist, a new string is created.

### Method
POST

### Endpoint
/setRange

### Parameters
#### Request Body
- **key** (K) - Required - The key to modify.
- **offset** (int) - Required - The offset at which to start overwriting.
- **value** (V) - Required - The value to write.

### Request Example
```json
{
  "key": "mykey",
  "offset": 5,
  "value": "new_part"
}
```

### Response
#### Success Response (200)
- **length** (int?) - The length of the string after modification.

#### Response Example
```json
{
  "length": 15
}
```
```

--------------------------------

### TableDefinition Constructor

Source: https://pub.dev/documentation/vania/latest/migration/TableDefinition-class

Creates a new TableDefinition instance to define a database table.

```APIDOC
## TableDefinition.new

### Description
Initializes a new TableDefinition.

### Method
Constructor

### Parameters
- **_tableName** (String) - Required - The name of the table.
- **_createFunction** (Future<void>) - Required - A function that creates the table.
- **connection** (MigrationConnection?) - Optional - The database connection to use.
- **adapter** (DatabaseAdapterInterface?) - Optional - The database adapter to use.
```

--------------------------------

### QueryBuilder Lead Method Implementation (Dart)

Source: https://pub.dev/documentation/vania/latest/orm_model/Model/lead

This Dart code implements the 'lead' method for the QueryBuilder class. It constructs the SQL LEAD window function string, including optional partitioning and ordering clauses, and adds it to the query. It throws an exception if the column name is empty.

```dart
@override
QueryBuilder lead(
  String column,
  {
  int offset = 1,
  dynamic defaultValue,
  String? partitionBy,
  String? orderBy,
  String? as,
}
) {
  if (column.isEmpty) {
    throw InvalidArgumentException(
        'Column name cannot be empty for LEAD function');
  }

  String leadFunc = "LEAD($column, $offset";
  if (defaultValue != null) {
    if (defaultValue is String) {
      leadFunc += ", '$defaultValue'";
    } else {
      leadFunc += ", $defaultValue";
    }
  }
  leadFunc += ")";

  final overClause = _buildOverClause(partitionBy: partitionBy, orderBy: orderBy);
  _addWindowFunction(leadFunc, overClause, as);
  return this;
}
```

--------------------------------

### Get Authenticated User Profile

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Retrieves the profile information of the currently authenticated user.

```APIDOC
## GET /profile

### Description
Retrieves the profile details of the currently logged-in user. Requires authentication.

### Method
GET

### Endpoint
/profile

### Parameters
None

### Request Example
(No request body or parameters needed for this endpoint)

### Response
#### Success Response (200)
- **user** (object) - Contains user details including id, name, email, and created_at.

#### Response Example
```json
{
  "user": {
    "id": 1,
    "name": "John Doe",
    "email": "test@example.com",
    "created_at": "2023-10-27T10:00:00.000Z"
  }
}
```

#### Error Response (401)
(If the user is not authenticated)
```json
{
  "error": "Unauthenticated"
}
```
```

--------------------------------

### Serve Files Inline with Vania

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Serve files directly in the browser, such as images, by setting the appropriate Content-Type header. Allows for inline display and configurable cache control.

```dart
import 'package:vania/vania.dart';
import 'dart:io';

// File response (inline display)
Router.get('/images/{filename}', (Request req) async {
  final filename = req.params()['filename'];
  final bytes = await File('storage/images/$filename').readAsBytes();
  return Response.file(filename, bytes, headers: {
    'Content-Type': 'image/jpeg',
    'Cache-Control': 'public, max-age=3600',
  });
});
```

--------------------------------

### Create Table Method Implementation (Dart)

Source: https://pub.dev/documentation/vania/latest/migration/Migration/create

This Dart code implements the `create` method for `TableDefinition`. It initializes the schema builder, sets the table name, and defines an asynchronous function `createFunction` to generate and execute the SQL `CREATE TABLE` statement. It includes specific logic for PostgreSQL adapters and general error handling for query execution.

```dart
TableDefinition create(String tableName, Function(Schema) callback,
    [bool ifNotExists = false]) {
  _schemaBuilder.reset();
  _schemaBuilder.setTableName(tableName);

  Future<void> createFunction() async {
    callback(_schemaBuilder);

    String sql = _schemaBuilder.generateCreateTableSql(tableName,
        ifNotExists: ifNotExists);

    if (_adapter != null && _adapter.driverName == 'pgsql') {
      final postgresAdapter = _adapter as dynamic;
      if (postgresAdapter.executeStatements != null) {
        await postgresAdapter.executeStatements(sql,
            (List<String> statements) async {
          for (String statement in statements) {
            await _connection.connection!.execute(statement);
          }
        });
        return;
      }
    }

    if (_adapter != null) {
      sql = _adapter.adaptQuery(sql);
    }
    try {
      await _connection.connection!.execute(sql);
    } on QueryException catch (e) {
      stderr.writeln(
        'Error executing statement: $sql\nError: ${e.cause}',
      );
      exit(0);
    }
  }

  return TableDefinition(tableName, createFunction,
      connection: _connection, adapter: _adapter);
}
```

--------------------------------

### CORSConfig Constructor and Properties

Source: https://pub.dev/documentation/vania/latest/vania/CORSConfig-class

Demonstrates the instantiation of the CORSConfig class with various parameters and highlights its core properties. These properties control aspects like enabling CORS, specifying allowed origins, HTTP methods, headers, and more. The constructor allows for flexible configuration of CORS settings.

```dart
CORSConfig.new({
  bool enabled = true,
  dynamic origin,
  dynamic methods,
  dynamic headers,
  dynamic exposeHeaders,
  bool? credentials,
  num? maxAge
});

// Example Usage:
final config = CORSConfig.new(
  origin: '*', // Allow all origins
  methods: ['GET', 'POST'], // Allow GET and POST methods
  headers: ['Content-Type'], // Allow Content-Type header
  credentials: true,
  maxAge: 86400 // Cache preflight request for 24 hours
);

print(config.enabled); // Output: true
print(config.origin); // Output: *
print(config.credentials); // Output: true
```

--------------------------------

### Truncate Migrations

Source: https://pub.dev/documentation/vania/latest/migration/MigrationConnection-class

Provides an example of truncating all existing migrations using the MigrationConnection. This is typically used for resetting the migration state.

```dart
await connection.truncateMigration();
```

--------------------------------

### Create Vania Production Build

Source: https://pub.dev/documentation/vania/latest/index

Generates a production-ready build of the Vania application. This build is optimized for deployment and can be deployed using provided Docker files.

```bash
vania build
```

--------------------------------

### LRANGE Command Implementation

Source: https://pub.dev/documentation/vania/latest/vania/ListCommands-class

Implements the LRANGE command to retrieve a range of elements from a list. It takes start and end indices and returns a Future<List<V>>.

```dart
Future<List<V>> lrange(K key, int startIndex, int endIndex) {
  // Implementation details for LRANGE command
  throw UnimplementedError();
}
```

--------------------------------

### Instantiate ConnectionMetrics

Source: https://pub.dev/documentation/vania/latest/query_builder/ConnectionMetrics-class

Creates a new instance of the ConnectionMetrics class. Requires active connections, maximum connections, and usage percentage to be provided.

```dart
ConnectionMetrics.new({
  required int activeConnections,
  required int maxConnections,
  required int usagePercentage
});
```

--------------------------------

### Router - HTTP Request Routing

Source: https://context7.com/context7/pub_dev_vania/llms.txt

Handles basic route registration for HTTP requests with support for all standard HTTP methods. Includes features for parameters, constraints, named routes, and route grouping with middleware.

```APIDOC
## Router - HTTP Request Routing

### Description
Basic route registration for handling HTTP requests with support for all standard HTTP methods. This section covers registering GET, POST, routes with parameters, pattern constraints, named routes, and route groups with prefixes and middleware.

### Method
GET, POST, DELETE (and others)

### Endpoint
Various endpoints including `/users`, `/users/{id}`, `/posts/{id}`, `/profile`, `/api/v1/users`, `/api/v1/users/{id}`, `/api/user/profile`, etc.

### Parameters

#### Path Parameters
- **id** (string) - Required - The identifier for the resource (e.g., user ID, post ID).

#### Query Parameters
None explicitly defined in examples, but can be accessed via `req.query()`.

#### Request Body
None explicitly defined for basic routes, but can be handled for POST/PUT requests using `req.input()`.

### Request Example
```dart
// GET route example
Router.get('/users', () {
  return Response.json({'users': []});
});

// POST route example
Router.post('/users', (Request req) async {
  final data = req.input();
  return Response.json({'created': true, 'data': data});
});

// Route with parameters example
Router.get('/users/{id}', (Request req) {
  final id = req.params()['id'];
  return Response.json({'user_id': id});
});

// Route group example
Router.group(() {
  Router.get('/users', () => Response.json({'users': []}));
  Router.post('/users', (Request req) => Response.json({'created': true}));
  Router.delete('/users/{id}', () => Response.json({'deleted': true}));
}, prefix: '/api/v1', middleware: [AuthMiddleware()]);
```

### Response
#### Success Response (200)
- **(dynamic)** - Varies based on the route handler function, typically a `Response` object containing JSON or other data.

#### Response Example
```json
{
  "users": []
}
```
```json
{
  "created": true,
  "data": {
    "key": "value"
  }
}
```
```json
{
  "user_id": "123"
}
```
```

--------------------------------

### Implement Database Index Creation (Dart)

Source: https://pub.dev/documentation/vania/latest/migration/Schema/index

This method implements the creation of database indexes. It takes an index type, a name, and a list of columns. It handles different index types by formatting the SQL statement accordingly. Dependencies include the `ColumnIndex` enum and a list of column names.

```Dart
@override
void index(ColumnIndex type, String name, List<String> columns) {
  if (type == ColumnIndex.indexKey) {
    _indexes.add('INDEX `$name` (${columns.map((e) => "`$e`").join(',')})');
  } else {
    _indexes.add(
        '${type.name.toUpperCase()} INDEX `$name` (${columns.map((e) => "`$e`").join(',')})');
  }
}
```

--------------------------------

### Connect to Redis Server - Dart

Source: https://pub.dev/documentation/vania/latest/vania/RedisClient/connect

Establishes a connection to a Redis server and sends the SELECT command to choose a database. It requires host, port, and db as parameters, with optional username and password for authentication. It returns a `Future<RedisClient>` upon successful connection.

```dart
static Future<RedisClient> connect(
  String host,
  int port, {
  required int db,
  String? username,
  String? password,
}) async {
  final rpc =
      await RedisProtocolClient.createConnection(host: host, port: port);

  if (password != null) {
    await _auth(rpc, username: username, password: password);
  }
  rpc.sendCommand(Resp(['SELECT', '$db']));
  final res = await rpc.receive();
  res.throwIfError();
  return RedisClient._(rpc);
}
```

--------------------------------

### Handle Future Errors with catchError (Dart)

Source: https://pub.dev/documentation/vania/latest/migration/TableDefinition/catchError

Demonstrates how to use the catchError method on a Future to handle potential errors. It includes an example of a conditional error test and an error callback. This method is crucial for managing asynchronous exceptions.

```dart
Future.delayed(
  const Duration(seconds: 1),
  () => throw 401,
).then((value) {
  throw 'Unreachable';
}).catchError((err) {
  print('Error: $err'); // Prints 401.
}, test: (error) {
  return error is int && error >= 400;
});

```

```dart
@override
Future<void> catchError(Function onError,
    {bool Function(Object error)? test}) {
  return _getExecutionFuture().catchError(onError, test: test);
}

```

--------------------------------

### Instantiate and Use RequestFile Class

Source: https://pub.dev/documentation/vania/latest/http_request/RequestFile-class

Demonstrates how to create a new instance of the RequestFile class and access its properties and methods. This class is useful for handling uploaded files in web applications.

```dart
import 'package:http_parser/http_parser.dart';

// Assuming MimeMultipart is available and instantiated elsewhere
MimeMultipart stream = ...; // Replace with actual MimeMultipart instance

final uploadedFile = RequestFile.new(
  filename: 'example.txt',
  filetype: 'text/plain',
  stream: stream,
);

print('Filename: ${uploadedFile.filename}');
print('Filetype: ${uploadedFile.filetype}');
print('Client MIME Type: ${uploadedFile.clientMimeType}');

// Lazily access bytes and size
final bytes = await uploadedFile.bytes;
final size = await uploadedFile.size;

print('File size: $size bytes');
print('File bytes length: ${bytes.length}');

// Example of moving the file
// await uploadedFile.move(toPath: '/path/to/destination', name: 'new_name.txt');

// Example of storing the file
// await uploadedFile.store(path: 'uploads/', name: 'stored_file.txt');
```

--------------------------------

### Dart simplePaginate Method Implementation

Source: https://pub.dev/documentation/vania/latest/orm_model/Model/simplePaginate

The simplePaginate method is an override that fetches paginated data. It calculates total pages, offset, and returns data along with pagination information. Dependencies include a 'count' method and a 'get' method for data retrieval.

```dart
@override
Future<Map<String, dynamic>> simplePaginate([
  int perPage = 15,
  List<String> columns = const ['*'],
  String? pageName,
  int? page,
]) async {
  int currentPage = page ?? getParam<int>('page', 1)!;
  int total = await count();
  final lastPage = (total / perPage).ceil();
  final offset = (currentPage - 1) * perPage;
  super.take(perPage).skip(offset);
  final pageData = await get();

  return {
    'data': pageData,
    'current_page': currentPage,
    'per_page': perPage,
    'total': total,
    'last_page': lastPage,
  };
}
```
Tokens:
Raw