Struct Engine 

pub struct Engine { /* private fields */ }

Main engine for schema synchronization

The engine coordinates all components to provide schema sync functionality. It’s designed to be used by the CLI layer, which handles mode-specific behavior (dry-run, validation, etc.).

Implementations

impl Engine

pub fn new( inspector: Box<dyn SchemaInspector>, runner: Box<dyn MigrationRunner>, planner: Box<dyn Planner>, executor: Box<dyn Executor>, diff_calculator: Box<dyn DiffCalculator>, snapshot_store: Option<Box<dyn SnapshotStore>>, ) -> Self

Create a new engine

Arguments

• inspector - Schema inspector for reading current schema
• runner - Migration runner for executing changes
• planner - Planner for creating migration plans
• executor - Executor for orchestrating execution
• diff_calculator - Calculator for computing diffs
• snapshot_store - Optional snapshot store for versioning

pub fn from_adapter( adapter: Box<dyn DatabaseAdapter>, planner: Box<dyn Planner>, executor: Box<dyn Executor>, diff_calculator: Box<dyn DiffCalculator>, snapshot_store: Option<Box<dyn SnapshotStore>>, ) -> Self

Create an engine from a database adapter

This is a convenience method that creates an engine with default implementations of planner, executor, and diff calculator.

pub async fn sync_tenant( &self, tenant: &TenantContext, target: Option<&SchemaSnapshot>, execute: bool, ) -> Result<SyncResult>

Sync a tenant’s schema to match a target snapshot

This is the main operation. It:

1. Inspects the current schema
2. Calculates the diff to the target
3. Creates a migration plan
4. Optionally executes the plan

Arguments

• tenant - The tenant context
• target - Target schema snapshot (or None to use stored snapshot)
• execute - Whether to actually execute the migration (false for dry-run)

Returns

Sync result with diff and execution details.

pub async fn inspect_tenant( &self, tenant: &TenantContext, ) -> Result<SchemaSnapshot>

Get the current schema snapshot for a tenant

pub fn calculate_diff( &self, from: &SchemaSnapshot, to: &SchemaSnapshot, ) -> SchemaDiff

Calculate diff between two snapshots

pub async fn list_tenants(&self) -> Result<Vec<TenantContext>>

List all tenants