create-syncular-app 0.1.3 → 0.2.1

package/template/generated/rust/syncular.rs

@@ -1,926 +0,0 @@
-// @generated by `cargo run --manifest-path rust/Cargo.toml -p syncular-codegen --`
-// Source: migrations/*.sql
-
-use serde_json::{json, Map, Value};
-pub use syncular_client::app_schema::{
-    AppTableMetadata, ColumnMetadata, CrdtYjsFieldMetadata, EncryptedFieldMetadata, ScopeMetadata,
-    ScopeSource,
-};
-#[allow(unused_imports)]
-use syncular_client::client::{
-    SubscriptionSpec, SyncChangedRow, SyncularClientConfig, SyncularCommandHistoryExecutor,
-    SyncularEncryptedCrdtMutationExecutor, SyncularLeasedMutationExecutor,
-    SyncularMutationExecutor,
-};
-use syncular_client::command_history::{
-    CommandHistoryEntry, CommandHistoryReceipt, CommandHistoryRecord, CommandHistoryState,
-};
-#[allow(unused_imports)]
-use syncular_client::crdt_yjs::{YjsUpdateEnvelope, YJS_PAYLOAD_KEY};
-use syncular_client::encryption::FieldEncryptionRule;
-use syncular_client::error::{Result, SyncularError};
-use syncular_client::protocol::{
-    random_syncular_id, IntoSyncularMutation, MutationCommit, MutationReceipt,
-    PendingSyncularMutation, SyncOperation, SyncularMutationBatch, SyncularMutationKind,
-};
-
-pub const APP_TABLES: &[&str] = &["tasks"];
-
-pub const TASKS_TABLE: &str = "tasks";
-
-pub const TASKS_COLUMNS: &[ColumnMetadata] = &[
-    ColumnMetadata {
-        name: "id",
-        type_family: "text",
-        notnull_required: false,
-        primary_key: true,
-    },
-    ColumnMetadata {
-        name: "title",
-        type_family: "text",
-        notnull_required: true,
-        primary_key: false,
-    },
-    ColumnMetadata {
-        name: "completed",
-        type_family: "integer",
-        notnull_required: true,
-        primary_key: false,
-    },
-    ColumnMetadata {
-        name: "user_id",
-        type_family: "text",
-        notnull_required: true,
-        primary_key: false,
-    },
-    ColumnMetadata {
-        name: "created_at",
-        type_family: "integer",
-        notnull_required: true,
-        primary_key: false,
-    },
-    ColumnMetadata {
-        name: "server_version",
-        type_family: "integer",
-        notnull_required: true,
-        primary_key: false,
-    },
-];
-
-pub const TASKS_BLOB_COLUMNS: &[&str] = &[];
-
-pub const TASKS_CRDT_YJS_FIELDS: &[CrdtYjsFieldMetadata] = &[];
-
-pub const TASKS_ENCRYPTED_FIELDS: &[EncryptedFieldMetadata] = &[];
-
-pub const TASKS_SCOPES: &[ScopeMetadata] = &[ScopeMetadata {
-    name: "user_id",
-    column: "user_id",
-    source: ScopeSource::ActorId,
-    required: true,
-}];
-
-pub const TASKS_METADATA: AppTableMetadata = AppTableMetadata {
-    name: "tasks",
-    primary_key_column: "id",
-    server_version_column: "server_version",
-    soft_delete_column: None,
-    subscription_id: "sub-tasks",
-    columns: TASKS_COLUMNS,
-    blob_columns: TASKS_BLOB_COLUMNS,
-    crdt_yjs_fields: TASKS_CRDT_YJS_FIELDS,
-    encrypted_fields: TASKS_ENCRYPTED_FIELDS,
-    scopes: TASKS_SCOPES,
-};
-
-pub const APP_TABLE_METADATA: &[AppTableMetadata] = &[TASKS_METADATA];
-
-pub fn table_metadata(table: &str) -> Option<&'static AppTableMetadata> {
-    APP_TABLE_METADATA
-        .iter()
-        .find(|metadata| metadata.name == table)
-}
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub struct TaskChangedFields {
-    pub id: bool,
-    pub title: bool,
-    pub completed: bool,
-    pub user_id: bool,
-    pub created_at: bool,
-    pub server_version: bool,
-}
-
-impl TaskChangedFields {
-    pub fn from_columns(columns: &[String]) -> Self {
-        Self {
-            id: columns.iter().any(|column| column == "id"),
-            title: columns.iter().any(|column| column == "title"),
-            completed: columns.iter().any(|column| column == "completed"),
-            user_id: columns.iter().any(|column| column == "user_id"),
-            created_at: columns.iter().any(|column| column == "created_at"),
-            server_version: columns.iter().any(|column| column == "server_version"),
-        }
-    }
-
-    pub fn contains(&self, column: &str) -> bool {
-        match column {
-            "id" => self.id,
-            "title" => self.title,
-            "completed" => self.completed,
-            "user_id" => self.user_id,
-            "created_at" => self.created_at,
-            "server_version" => self.server_version,
-            _ => false,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct TaskChangedRow<'a> {
-    pub raw: &'a SyncChangedRow,
-    pub changed: TaskChangedFields,
-    pub crdt: TaskChangedFields,
-}
-
-impl<'a> TaskChangedRow<'a> {
-    pub fn from_raw(row: &'a SyncChangedRow) -> Option<Self> {
-        if row.table != "tasks" {
-            return None;
-        }
-        Some(Self {
-            raw: row,
-            changed: TaskChangedFields::from_columns(&row.changed_fields),
-            crdt: TaskChangedFields::from_columns(&row.crdt_fields),
-        })
-    }
-
-    pub fn row_id(&self) -> Option<&str> {
-        self.raw.row_id.as_deref()
-    }
-
-    pub fn is_insert(&self) -> bool {
-        self.raw.operation == "insert"
-    }
-
-    pub fn is_update(&self) -> bool {
-        self.raw.operation == "update"
-    }
-
-    pub fn is_delete(&self) -> bool {
-        self.raw.operation == "delete"
-    }
-}
-
-pub fn task_changed_rows<'a>(
-    rows: impl IntoIterator<Item = &'a SyncChangedRow>,
-) -> Vec<TaskChangedRow<'a>> {
-    rows.into_iter()
-        .filter_map(TaskChangedRow::from_raw)
-        .collect()
-}
-
-pub fn generated_field_encryption_rules() -> Vec<FieldEncryptionRule> {
-    Vec::new()
-}
-
-pub fn default_subscriptions(config: &SyncularClientConfig) -> Vec<SubscriptionSpec> {
-    vec![tasks_subscription(&config.actor_id)]
-}
-
-pub fn default_subscriptions_with_bootstrap_phases(
-    config: &SyncularClientConfig,
-    bootstrap_phases: &[(&str, i64)],
-) -> Vec<SubscriptionSpec> {
-    let mut subscriptions = default_subscriptions(config);
-    apply_bootstrap_phases(&mut subscriptions, bootstrap_phases);
-    subscriptions
-}
-
-pub fn apply_bootstrap_phases(
-    subscriptions: &mut [SubscriptionSpec],
-    bootstrap_phases: &[(&str, i64)],
-) {
-    for subscription in subscriptions {
-        if let Some((_, phase)) = bootstrap_phases
-            .iter()
-            .find(|(key, _)| *key == subscription.id || *key == subscription.table)
-        {
-            subscription.bootstrap_phase = *phase;
-        }
-    }
-}
-
-pub fn with_bootstrap_phase(
-    mut subscription: SubscriptionSpec,
-    bootstrap_phase: i64,
-) -> SubscriptionSpec {
-    subscription.bootstrap_phase = bootstrap_phase;
-    subscription
-}
-
-pub fn tasks_subscription(user_id: &str) -> SubscriptionSpec {
-    let mut scopes = Map::new();
-    scopes.insert("user_id".to_string(), json!(user_id));
-    let params = Map::new();
-
-    SubscriptionSpec {
-        id: "sub-tasks".to_string(),
-        table: "tasks".to_string(),
-        scopes,
-        params,
-        bootstrap_phase: 0,
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct NewTask {
-    pub id: String,
-    pub title: String,
-    pub completed: i32,
-    pub user_id: String,
-    pub created_at: i64,
-}
-
-impl NewTask {
-    pub fn new(id: &str, title: &str, user_id: &str) -> Self {
-        Self {
-            id: id.to_string(),
-            title: title.to_string(),
-            completed: 0,
-            user_id: user_id.to_string(),
-            created_at: 0,
-        }
-    }
-
-    pub fn with_generated_id(title: &str, user_id: &str) -> Self {
-        Self {
-            id: random_syncular_id(),
-            title: title.to_string(),
-            completed: 0,
-            user_id: user_id.to_string(),
-            created_at: 0,
-        }
-    }
-
-    pub fn row_json(&self) -> Value {
-        let mut row = Map::new();
-        row.insert("id".to_string(), json!(&self.id));
-        row.insert("title".to_string(), json!(&self.title));
-        row.insert("completed".to_string(), json!(&self.completed));
-        row.insert("user_id".to_string(), json!(&self.user_id));
-        row.insert("created_at".to_string(), json!(&self.created_at));
-        Value::Object(row)
-    }
-
-    pub fn sync_operation(&self) -> SyncOperation {
-        let mut payload = Map::new();
-        payload.insert("title".to_string(), json!(&self.title));
-        payload.insert("completed".to_string(), json!(&self.completed));
-        payload.insert("user_id".to_string(), json!(&self.user_id));
-        payload.insert("created_at".to_string(), json!(&self.created_at));
-
-        SyncOperation {
-            table: "tasks".to_string(),
-            row_id: self.id.clone(),
-            op: "upsert".to_string(),
-            payload: Some(Value::Object(payload)),
-            base_version: Some(0),
-        }
-    }
-}
-
-impl IntoSyncularMutation for NewTask {
-    fn into_syncular_mutation(self) -> PendingSyncularMutation {
-        let row_id = self.id.clone();
-        PendingSyncularMutation {
-            kind: SyncularMutationKind::Insert,
-            table: "tasks".to_string(),
-            row_id,
-            payload: self.sync_operation().payload,
-            base_version: None,
-            local_row: Some(self.row_json()),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct TaskPatch {
-    row_id: String,
-    base_version: Option<i64>,
-    title: Option<String>,
-    completed: Option<i32>,
-    user_id: Option<String>,
-    created_at: Option<i64>,
-}
-
-impl TaskPatch {
-    pub fn new(row_id: &str) -> Self {
-        Self {
-            row_id: row_id.to_string(),
-            base_version: None,
-            title: None,
-            completed: None,
-            user_id: None,
-            created_at: None,
-        }
-    }
-
-    pub fn base_version(mut self, base_version: i64) -> Self {
-        self.base_version = Some(base_version);
-        self
-    }
-
-    pub fn title(mut self, title: &str) -> Self {
-        self.title = Some(title.to_string());
-        self
-    }
-
-    pub fn completed(mut self, completed: i32) -> Self {
-        self.completed = Some(completed);
-        self
-    }
-
-    pub fn user_id(mut self, user_id: &str) -> Self {
-        self.user_id = Some(user_id.to_string());
-        self
-    }
-
-    pub fn created_at(mut self, created_at: i64) -> Self {
-        self.created_at = Some(created_at);
-        self
-    }
-
-    pub fn payload_json(&self) -> Value {
-        let mut payload = Map::new();
-        if let Some(value) = &self.title {
-            payload.insert("title".to_string(), json!(value));
-        }
-        if let Some(value) = &self.completed {
-            payload.insert("completed".to_string(), json!(value));
-        }
-        if let Some(value) = &self.user_id {
-            payload.insert("user_id".to_string(), json!(value));
-        }
-        if let Some(value) = &self.created_at {
-            payload.insert("created_at".to_string(), json!(value));
-        }
-        Value::Object(payload)
-    }
-
-    pub fn sync_operation(&self) -> SyncOperation {
-        SyncOperation {
-            table: "tasks".to_string(),
-            row_id: self.row_id.clone(),
-            op: "upsert".to_string(),
-            payload: Some(self.payload_json()),
-            base_version: self.base_version,
-        }
-    }
-}
-
-impl IntoSyncularMutation for TaskPatch {
-    fn into_syncular_mutation(self) -> PendingSyncularMutation {
-        let payload = self.payload_json();
-        PendingSyncularMutation {
-            kind: SyncularMutationKind::Update,
-            table: "tasks".to_string(),
-            row_id: self.row_id,
-            payload: Some(payload),
-            base_version: self.base_version,
-            local_row: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct DeleteTask {
-    row_id: String,
-    base_version: Option<i64>,
-}
-
-impl DeleteTask {
-    pub fn new(row_id: &str) -> Self {
-        Self {
-            row_id: row_id.to_string(),
-            base_version: None,
-        }
-    }
-
-    pub fn base_version(mut self, base_version: i64) -> Self {
-        self.base_version = Some(base_version);
-        self
-    }
-
-    pub fn sync_operation(&self) -> SyncOperation {
-        SyncOperation {
-            table: "tasks".to_string(),
-            row_id: self.row_id.clone(),
-            op: "delete".to_string(),
-            payload: None,
-            base_version: self.base_version,
-        }
-    }
-}
-
-impl IntoSyncularMutation for DeleteTask {
-    fn into_syncular_mutation(self) -> PendingSyncularMutation {
-        PendingSyncularMutation {
-            kind: SyncularMutationKind::Delete,
-            table: "tasks".to_string(),
-            row_id: self.row_id,
-            payload: None,
-            base_version: self.base_version,
-            local_row: None,
-        }
-    }
-}
-
-pub fn delete_task(row_id: &str, base_version: Option<i64>) -> SyncOperation {
-    SyncOperation {
-        table: "tasks".to_string(),
-        row_id: row_id.to_string(),
-        op: "delete".to_string(),
-        payload: None,
-        base_version,
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct InsertReceipt {
-    pub id: String,
-    pub commit: MutationReceipt,
-}
-
-#[derive(Debug, Clone)]
-pub struct InsertManyReceipt {
-    pub ids: Vec<String>,
-    pub commit: MutationReceipt,
-}
-
-pub trait SyncularGeneratedMutationsExt: SyncularMutationExecutor {
-    fn mutations(&mut self) -> SyncularAppMutations<'_, Self>
-    where
-        Self: Sized,
-    {
-        SyncularAppMutations { client: self }
-    }
-
-    fn leased_mutations(&mut self) -> SyncularAppLeasedMutations<'_, Self>
-    where
-        Self: Sized + SyncularLeasedMutationExecutor,
-    {
-        SyncularAppLeasedMutations { client: self }
-    }
-
-    fn command_history(&mut self) -> SyncularAppCommandHistory<'_, Self>
-    where
-        Self: Sized + SyncularCommandHistoryExecutor,
-    {
-        SyncularAppCommandHistory { client: self }
-    }
-
-    fn commit<R>(
-        &mut self,
-        f: impl FnOnce(&mut SyncularAppMutationTx<'_>) -> Result<R>,
-    ) -> Result<MutationCommit<R>>
-    where
-        Self: Sized,
-    {
-        let mut batch = SyncularMutationBatch::new();
-        let result = {
-            let mut tx = SyncularAppMutationTx { batch: &mut batch };
-            f(&mut tx)?
-        };
-        let commit = self.apply_mutation_batch(batch)?;
-        Ok(MutationCommit { result, commit })
-    }
-
-    fn commit_with_history<R>(
-        &mut self,
-        f: impl FnOnce(&mut SyncularAppMutationTx<'_>) -> Result<R>,
-    ) -> Result<MutationCommit<R>>
-    where
-        Self: Sized + SyncularCommandHistoryExecutor,
-    {
-        syncular_commit_with_history(self, "mutations", f)
-    }
-
-    fn commit_leased<R>(
-        &mut self,
-        f: impl FnOnce(&mut SyncularAppMutationTx<'_>) -> Result<R>,
-    ) -> Result<MutationCommit<R>>
-    where
-        Self: Sized + SyncularLeasedMutationExecutor,
-    {
-        let mut batch = SyncularMutationBatch::new();
-        let result = {
-            let mut tx = SyncularAppMutationTx { batch: &mut batch };
-            f(&mut tx)?
-        };
-        let commit = self.apply_leased_mutation_batch(batch)?;
-        Ok(MutationCommit { result, commit })
-    }
-
-    fn commit_leased_with_history<R>(
-        &mut self,
-        f: impl FnOnce(&mut SyncularAppMutationTx<'_>) -> Result<R>,
-    ) -> Result<MutationCommit<R>>
-    where
-        Self: Sized + SyncularCommandHistoryExecutor,
-    {
-        syncular_commit_with_history(self, "leasedMutations", f)
-    }
-}
-
-impl<C> SyncularGeneratedMutationsExt for C where C: SyncularMutationExecutor {}
-
-pub struct SyncularAppMutations<'a, C: SyncularMutationExecutor + ?Sized> {
-    client: &'a mut C,
-}
-
-pub struct SyncularAppLeasedMutations<'a, C: SyncularLeasedMutationExecutor + ?Sized> {
-    client: &'a mut C,
-}
-
-pub struct SyncularAppMutationTx<'a> {
-    batch: &'a mut SyncularMutationBatch,
-}
-
-pub struct SyncularAppCommandHistory<'a, C: SyncularCommandHistoryExecutor + ?Sized> {
-    client: &'a mut C,
-}
-
-impl<C> SyncularAppCommandHistory<'_, C>
-where
-    C: SyncularCommandHistoryExecutor + ?Sized,
-{
-    pub fn can_undo(&mut self) -> Result<bool> {
-        Ok(self
-            .client
-            .command_history_latest(CommandHistoryState::Done)?
-            .is_some())
-    }
-
-    pub fn can_redo(&mut self) -> Result<bool> {
-        Ok(self
-            .client
-            .command_history_latest(CommandHistoryState::Undone)?
-            .is_some())
-    }
-
-    pub fn latest_undo(&mut self) -> Result<Option<CommandHistoryRecord>> {
-        self.client
-            .command_history_latest(CommandHistoryState::Done)
-    }
-
-    pub fn latest_redo(&mut self) -> Result<Option<CommandHistoryRecord>> {
-        self.client
-            .command_history_latest(CommandHistoryState::Undone)
-    }
-
-    pub fn undo_last(&mut self) -> Result<CommandHistoryReceipt> {
-        syncular_replay_command_history(self.client, CommandHistoryState::Done)
-    }
-
-    pub fn redo_last(&mut self) -> Result<CommandHistoryReceipt> {
-        syncular_replay_command_history(self.client, CommandHistoryState::Undone)
-    }
-}
-
-fn syncular_commit_with_history<C, R>(
-    client: &mut C,
-    mutation_scope: &str,
-    f: impl FnOnce(&mut SyncularAppMutationTx<'_>) -> Result<R>,
-) -> Result<MutationCommit<R>>
-where
-    C: SyncularCommandHistoryExecutor + ?Sized,
-{
-    let mut batch = SyncularMutationBatch::new();
-    let result = {
-        let mut tx = SyncularAppMutationTx { batch: &mut batch };
-        f(&mut tx)?
-    };
-    let commit = client.apply_command_history_tracked_batch(mutation_scope, batch)?;
-    Ok(MutationCommit { result, commit })
-}
-
-fn syncular_replay_command_history<C>(
-    client: &mut C,
-    state: CommandHistoryState,
-) -> Result<CommandHistoryReceipt>
-where
-    C: SyncularCommandHistoryExecutor + ?Sized,
-{
-    let command = client.command_history_latest(state)?.ok_or_else(|| {
-        syncular_command_history_error(
-            "sync.command_history_empty",
-            "there is no Syncular command to replay",
-        )
-    })?;
-    syncular_assert_command_history_safe(&command)?;
-    let undo = state == CommandHistoryState::Done;
-    syncular_assert_command_history_current_rows(client, &command, undo)?;
-
-    let mut batch = SyncularMutationBatch::new();
-    if undo {
-        for entry in command.entries.iter().rev() {
-            batch.push(syncular_command_history_mutation_for_snapshot(
-                &entry.table,
-                &entry.row_id,
-                &entry.before,
-            )?);
-        }
-    } else {
-        for entry in &command.entries {
-            batch.push(syncular_command_history_mutation_for_snapshot(
-                &entry.table,
-                &entry.row_id,
-                &entry.after,
-            )?);
-        }
-    }
-
-    let commit = client.apply_command_history_batch(&command.mutation_scope, batch)?;
-    let next_state = if undo {
-        CommandHistoryState::Undone
-    } else {
-        CommandHistoryState::Done
-    };
-    client.command_history_mark(&command.id, next_state, &commit)?;
-    Ok(CommandHistoryReceipt {
-        command_id: command.id,
-        commit,
-    })
-}
-
-fn syncular_assert_command_history_current_rows<C>(
-    client: &mut C,
-    command: &CommandHistoryRecord,
-    undo: bool,
-) -> Result<()>
-where
-    C: SyncularCommandHistoryExecutor + ?Sized,
-{
-    for entry in &command.entries {
-        let current = client.command_history_current_row_json(&entry.table, &entry.row_id)?;
-        let expected = if undo { &entry.after } else { &entry.before };
-        if &current != expected {
-            return Err(syncular_command_history_error(
-                "sync.command_history_conflict",
-                &format!(
-                    "cannot replay Syncular command {} because {}.{} changed since it was recorded",
-                    command.id, entry.table, entry.row_id
-                ),
-            ));
-        }
-    }
-    Ok(())
-}
-
-fn syncular_assert_command_history_safe(command: &CommandHistoryRecord) -> Result<()> {
-    for entry in &command.entries {
-        let unsafe_fields = syncular_command_history_unsafe_fields(entry)?;
-        if !unsafe_fields.is_empty() {
-            return Err(syncular_command_history_error(
-                "sync.command_history_unsafe_field",
-                &format!(
-                    "cannot replay Syncular command {} because {}.{} changed unsafe fields: {}",
-                    command.id,
-                    entry.table,
-                    entry.row_id,
-                    unsafe_fields.join(", ")
-                ),
-            ));
-        }
-    }
-    Ok(())
-}
-
-fn syncular_command_history_mutation_for_snapshot(
-    table: &str,
-    row_id: &str,
-    snapshot: &Option<Value>,
-) -> Result<PendingSyncularMutation> {
-    match snapshot {
-        None => Ok(PendingSyncularMutation {
-            kind: SyncularMutationKind::Delete,
-            table: table.to_string(),
-            row_id: row_id.to_string(),
-            payload: None,
-            base_version: None,
-            local_row: None,
-        }),
-        Some(snapshot) => Ok(PendingSyncularMutation {
-            kind: SyncularMutationKind::Upsert,
-            table: table.to_string(),
-            row_id: row_id.to_string(),
-            payload: Some(syncular_command_history_payload_for_snapshot(
-                table, snapshot,
-            )?),
-            base_version: None,
-            local_row: None,
-        }),
-    }
-}
-
-fn syncular_command_history_payload_for_snapshot(table: &str, snapshot: &Value) -> Result<Value> {
-    let Some(object) = snapshot.as_object() else {
-        return Err(syncular_command_history_error(
-            "sync.command_history_conflict",
-            "command history snapshot must be a JSON object",
-        ));
-    };
-    let mut payload: Map<String, Value> = object.clone();
-    match table {
-        "tasks" => {
-            payload.remove("id");
-            payload.remove("server_version");
-            Ok(())
-        }
-        _ => Err(syncular_command_history_error(
-            "sync.command_history_table_unsupported",
-            &format!("cannot replay undo history for unsupported table {table}"),
-        )),
-    }?;
-    Ok(Value::Object(payload))
-}
-
-fn syncular_command_history_unsafe_fields(
-    entry: &CommandHistoryEntry,
-) -> Result<Vec<&'static str>> {
-    #[allow(unused_mut)]
-    let mut fields = Vec::new();
-    match entry.table.as_str() {
-        "tasks" => Ok(fields),
-        _ => Err(syncular_command_history_error(
-            "sync.command_history_table_unsupported",
-            &format!(
-                "cannot replay undo history for unsupported table {}",
-                entry.table
-            ),
-        )),
-    }
-}
-
-#[allow(dead_code)]
-fn syncular_command_history_push_unsafe_field(
-    fields: &mut Vec<&'static str>,
-    entry: &CommandHistoryEntry,
-    field: &'static str,
-) {
-    if syncular_command_history_snapshot_field(&entry.before, field)
-        != syncular_command_history_snapshot_field(&entry.after, field)
-        && !fields.contains(&field)
-    {
-        fields.push(field);
-    }
-}
-
-#[allow(dead_code)]
-fn syncular_command_history_snapshot_field<'a>(
-    snapshot: &'a Option<Value>,
-    field: &str,
-) -> Option<&'a Value> {
-    snapshot.as_ref()?.as_object()?.get(field)
-}
-
-fn syncular_command_history_error(code: &str, message: &str) -> SyncularError {
-    SyncularError::config(format!("{code}: {message}"))
-}
-
-impl<'a, C> SyncularAppMutations<'a, C>
-where
-    C: SyncularMutationExecutor + ?Sized,
-{
-    pub fn tasks(self) -> TaskMutations<'a, C> {
-        TaskMutations {
-            client: self.client,
-        }
-    }
-}
-
-impl<'a, C> SyncularAppLeasedMutations<'a, C>
-where
-    C: SyncularLeasedMutationExecutor + ?Sized,
-{
-    pub fn tasks(self) -> TaskLeasedMutations<'a, C> {
-        TaskLeasedMutations {
-            client: self.client,
-        }
-    }
-}
-
-impl<'a> SyncularAppMutationTx<'a> {
-    pub fn tasks(&mut self) -> TaskMutationTx<'_> {
-        TaskMutationTx { batch: self.batch }
-    }
-}
-
-pub struct TaskMutations<'a, C: SyncularMutationExecutor + ?Sized> {
-    client: &'a mut C,
-}
-
-impl<C> TaskMutations<'_, C>
-where
-    C: SyncularMutationExecutor + ?Sized,
-{
-    pub fn insert(self, row: NewTask) -> Result<InsertReceipt> {
-        let id = row.id.clone();
-        let commit = self.client.apply_mutation(row)?;
-        Ok(InsertReceipt { id, commit })
-    }
-
-    pub fn insert_many(self, rows: impl IntoIterator<Item = NewTask>) -> Result<InsertManyReceipt> {
-        let mut batch = SyncularMutationBatch::new();
-        let mut ids = Vec::new();
-        for row in rows {
-            ids.push(row.id.clone());
-            batch.push(row);
-        }
-        let commit = self.client.apply_mutation_batch(batch)?;
-        Ok(InsertManyReceipt { ids, commit })
-    }
-
-    pub fn update(self, patch: TaskPatch) -> Result<MutationReceipt> {
-        self.client.apply_mutation(patch)
-    }
-
-    pub fn delete(self, row_id: &str) -> Result<MutationReceipt> {
-        self.client.apply_mutation(DeleteTask::new(row_id))
-    }
-}
-
-pub struct TaskLeasedMutations<'a, C: SyncularLeasedMutationExecutor + ?Sized> {
-    client: &'a mut C,
-}
-
-impl<C> TaskLeasedMutations<'_, C>
-where
-    C: SyncularLeasedMutationExecutor + ?Sized,
-{
-    pub fn insert(self, row: NewTask) -> Result<InsertReceipt> {
-        let id = row.id.clone();
-        let commit = self.client.apply_leased_mutation(row)?;
-        Ok(InsertReceipt { id, commit })
-    }
-
-    pub fn insert_many(self, rows: impl IntoIterator<Item = NewTask>) -> Result<InsertManyReceipt> {
-        let mut batch = SyncularMutationBatch::new();
-        let mut ids = Vec::new();
-        for row in rows {
-            ids.push(row.id.clone());
-            batch.push(row);
-        }
-        let commit = self.client.apply_leased_mutation_batch(batch)?;
-        Ok(InsertManyReceipt { ids, commit })
-    }
-
-    pub fn update(self, patch: TaskPatch) -> Result<MutationReceipt> {
-        self.client.apply_leased_mutation(patch)
-    }
-
-    pub fn delete(self, row_id: &str) -> Result<MutationReceipt> {
-        self.client.apply_leased_mutation(DeleteTask::new(row_id))
-    }
-}
-
-pub struct TaskMutationTx<'a> {
-    batch: &'a mut SyncularMutationBatch,
-}
-
-impl TaskMutationTx<'_> {
-    pub fn insert(self, row: NewTask) -> Result<String> {
-        let id = row.id.clone();
-        self.batch.push(row);
-        Ok(id)
-    }
-
-    pub fn insert_many(self, rows: impl IntoIterator<Item = NewTask>) -> Result<Vec<String>> {
-        let mut ids = Vec::new();
-        for row in rows {
-            ids.push(row.id.clone());
-            self.batch.push(row);
-        }
-        Ok(ids)
-    }
-
-    pub fn update(self, patch: TaskPatch) -> Result<()> {
-        self.batch.push(patch);
-        Ok(())
-    }
-
-    pub fn delete(self, row_id: &str) -> Result<()> {
-        self.batch.push(DeleteTask::new(row_id));
-        Ok(())
-    }
-}
-
-pub mod prelude {
-    pub use super::{
-        DeleteTask, InsertManyReceipt, InsertReceipt, NewTask, SyncularAppCommandHistory,
-        SyncularAppLeasedMutations, SyncularAppMutationTx, SyncularAppMutations,
-        SyncularGeneratedMutationsExt, TaskLeasedMutations, TaskMutationTx, TaskMutations,
-        TaskPatch,
-    };
-}