brokerage-db 0.2.5

Database management for trader brokerage data with a MongoDB backend.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use crate::{security::Security, trade_execution::TradeExecution};
use anyhow::Result;
use async_trait::async_trait;
use bson::doc;
use mongodb::{IndexModel, options::IndexOptions};
use tfiala_mongodb_migrator::migrator::Env;

pub struct Migration003 {}

const TRADE_EXECUTIONS_UNIQUE_INDEX_NAME: &str = "trade_executions_unique_idx";
const TRADE_EXECUTIONS_BY_ACCOUNT_SECURITY_TIMESTAMP_INDEX_NAME: &str =
    "trade_executions_by_account_security_timestamp_idx";
const TRADE_EXECUTIONS_BY_ACCOUNT_TIMESTAMP_INDEX_NAME: &str =
    "trade_executions_by_account_timestamp_idx";

#[async_trait]
impl tfiala_mongodb_migrator::migration::Migration for Migration003 {
    async fn up(&self, env: Env) -> Result<()> {
        let db = env.db.unwrap();

        //
        // Create initial trade execution collection
        //
        db.create_collection(TradeExecution::COLLECTION_NAME)
            .await?;

        let collection = db.collection::<TradeExecution>(TradeExecution::COLLECTION_NAME);
        let indexes = vec![
            IndexModel::builder()
                .keys(doc! { "brokerage_account_id": 1, "brokerage_execution_id": 1 })
                .options(
                    IndexOptions::builder()
                        .name(Some(TRADE_EXECUTIONS_UNIQUE_INDEX_NAME.to_owned()))
                        .unique(true)
                        .build(),
                )
                .build(),
            IndexModel::builder()
                .keys(
                    doc! { "brokerage_account_id": 1, "security_id": 1, "execution_timestamp": 1 },
                )
                .options(
                    IndexOptions::builder()
                        .name(Some(
                            TRADE_EXECUTIONS_BY_ACCOUNT_SECURITY_TIMESTAMP_INDEX_NAME.to_owned(),
                        ))
                        .build(),
                )
                .build(),
            IndexModel::builder()
                .keys(doc! { "brokerage_account_id": 1, "execution_timestamp": 1 })
                .options(
                    IndexOptions::builder()
                        .name(Some(
                            TRADE_EXECUTIONS_BY_ACCOUNT_TIMESTAMP_INDEX_NAME.to_owned(),
                        ))
                        .build(),
                )
                .build(),
        ];

        collection.create_indexes(indexes).await?;

        Ok(())
    }

    async fn down(&self, env: Env) -> Result<()> {
        let db = env.db.unwrap();
        let collection = db.collection::<Security>(TradeExecution::COLLECTION_NAME);

        collection
            .drop_index(TRADE_EXECUTIONS_BY_ACCOUNT_TIMESTAMP_INDEX_NAME)
            .await?;

        collection
            .drop_index(TRADE_EXECUTIONS_BY_ACCOUNT_SECURITY_TIMESTAMP_INDEX_NAME)
            .await?;

        collection
            .drop_index(TRADE_EXECUTIONS_UNIQUE_INDEX_NAME)
            .await?;

        collection.drop().await?;

        Ok(())
    }
}