openauth-plugins 0.0.5

Official OpenAuth plugin modules.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use indexmap::IndexMap;
use openauth_core::db::{DbField, DbFieldType, DbTable, TableOptions};
use openauth_core::plugin::PluginSchemaContribution;

use super::{API_KEY_MODEL, API_KEY_TABLE};

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ApiKeySchemaOptions {
    pub table: TableOptions,
}

pub fn schema_contribution(options: &ApiKeySchemaOptions) -> PluginSchemaContribution {
    PluginSchemaContribution::table(
        API_KEY_MODEL,
        table(
            &options.table,
            [
                ("id", DbField::new("id", DbFieldType::String)),
                (
                    "config_id",
                    DbField::new("config_id", DbFieldType::String).indexed(),
                ),
                ("name", DbField::new("name", DbFieldType::String).optional()),
                (
                    "start",
                    DbField::new("start", DbFieldType::String).optional(),
                ),
                (
                    "prefix",
                    DbField::new("prefix", DbFieldType::String).optional(),
                ),
                ("key", DbField::new("key", DbFieldType::String).indexed()),
                (
                    "reference_id",
                    DbField::new("reference_id", DbFieldType::String).indexed(),
                ),
                (
                    "refill_interval",
                    DbField::new("refill_interval", DbFieldType::Number).optional(),
                ),
                (
                    "refill_amount",
                    DbField::new("refill_amount", DbFieldType::Number).optional(),
                ),
                (
                    "last_refill_at",
                    DbField::new("last_refill_at", DbFieldType::Timestamp).optional(),
                ),
                ("enabled", DbField::new("enabled", DbFieldType::Boolean)),
                (
                    "rate_limit_enabled",
                    DbField::new("rate_limit_enabled", DbFieldType::Boolean),
                ),
                (
                    "rate_limit_time_window",
                    DbField::new("rate_limit_time_window", DbFieldType::Number).optional(),
                ),
                (
                    "rate_limit_max",
                    DbField::new("rate_limit_max", DbFieldType::Number).optional(),
                ),
                (
                    "request_count",
                    DbField::new("request_count", DbFieldType::Number),
                ),
                (
                    "remaining",
                    DbField::new("remaining", DbFieldType::Number).optional(),
                ),
                (
                    "last_request",
                    DbField::new("last_request", DbFieldType::Timestamp).optional(),
                ),
                (
                    "expires_at",
                    DbField::new("expires_at", DbFieldType::Timestamp).optional(),
                ),
                (
                    "created_at",
                    DbField::new("created_at", DbFieldType::Timestamp),
                ),
                (
                    "updated_at",
                    DbField::new("updated_at", DbFieldType::Timestamp),
                ),
                (
                    "metadata",
                    DbField::new("metadata", DbFieldType::Json).optional(),
                ),
                (
                    "permissions",
                    DbField::new("permissions", DbFieldType::Json).optional(),
                ),
            ],
        ),
    )
}

fn table<const N: usize>(options: &TableOptions, fields: [(&str, DbField); N]) -> DbTable {
    let mut fields = fields
        .into_iter()
        .map(|(logical_name, mut field)| {
            if let Some(db_name) = options.field_names.get(logical_name) {
                field.name = db_name.clone();
            }
            (logical_name.to_owned(), field)
        })
        .collect::<IndexMap<_, _>>();
    fields.extend(options.additional_fields.clone());
    DbTable {
        name: options
            .name
            .clone()
            .unwrap_or_else(|| API_KEY_TABLE.to_owned()),
        fields,
        order: Some(30),
    }
}