deno_kv 0.87.0

Implementation of the Deno database API
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.

#[derive(Clone, Copy, Debug)]
pub struct KvConfig {
  pub max_write_key_size_bytes: usize,
  pub max_read_key_size_bytes: usize,
  pub max_value_size_bytes: usize,
  pub max_read_ranges: usize,
  pub max_read_entries: usize,
  pub max_checks: usize,
  pub max_mutations: usize,
  pub max_watched_keys: usize,
  pub max_total_mutation_size_bytes: usize,
  pub max_total_key_size_bytes: usize,
}

impl KvConfig {
  pub fn builder() -> KvConfigBuilder {
    KvConfigBuilder::default()
  }
}

#[derive(Default)]
pub struct KvConfigBuilder {
  max_write_key_size_bytes: Option<usize>,
  max_value_size_bytes: Option<usize>,
  max_read_ranges: Option<usize>,
  max_read_entries: Option<usize>,
  max_checks: Option<usize>,
  max_mutations: Option<usize>,
  max_watched_keys: Option<usize>,
  max_total_mutation_size_bytes: Option<usize>,
  max_total_key_size_bytes: Option<usize>,
}

impl KvConfigBuilder {
  pub fn new() -> Self {
    Self::default()
  }

  pub fn max_write_key_size_bytes(
    &mut self,
    max_write_key_size_bytes: usize,
  ) -> &mut Self {
    self.max_write_key_size_bytes = Some(max_write_key_size_bytes);
    self
  }

  pub fn max_value_size_bytes(
    &mut self,
    max_value_size_bytes: usize,
  ) -> &mut Self {
    self.max_value_size_bytes = Some(max_value_size_bytes);
    self
  }

  pub fn max_read_ranges(&mut self, max_read_ranges: usize) -> &mut Self {
    self.max_read_ranges = Some(max_read_ranges);
    self
  }

  pub fn max_read_entries(&mut self, max_read_entries: usize) -> &mut Self {
    self.max_read_entries = Some(max_read_entries);
    self
  }

  pub fn max_checks(&mut self, max_checks: usize) -> &mut Self {
    self.max_checks = Some(max_checks);
    self
  }

  pub fn max_mutations(&mut self, max_mutations: usize) -> &mut Self {
    self.max_mutations = Some(max_mutations);
    self
  }

  pub fn max_watched_keys(&mut self, max_watched_keys: usize) -> &mut Self {
    self.max_watched_keys = Some(max_watched_keys);
    self
  }

  pub fn max_total_mutation_size_bytes(
    &mut self,
    max_total_mutation_size_bytes: usize,
  ) -> &mut Self {
    self.max_total_mutation_size_bytes = Some(max_total_mutation_size_bytes);
    self
  }

  pub fn max_total_key_size_bytes(
    &mut self,
    max_total_key_size_bytes: usize,
  ) -> &mut Self {
    self.max_total_key_size_bytes = Some(max_total_key_size_bytes);
    self
  }

  pub fn build(&self) -> KvConfig {
    const MAX_WRITE_KEY_SIZE_BYTES: usize = 2048;
    // range selectors can contain 0x00 or 0xff suffixes
    const MAX_READ_KEY_SIZE_BYTES: usize = MAX_WRITE_KEY_SIZE_BYTES + 1;
    const MAX_VALUE_SIZE_BYTES: usize = 65536;
    const MAX_READ_RANGES: usize = 10;
    const MAX_READ_ENTRIES: usize = 1000;
    const MAX_CHECKS: usize = 100;
    const MAX_MUTATIONS: usize = 1000;
    const MAX_WATCHED_KEYS: usize = 10;
    const MAX_TOTAL_MUTATION_SIZE_BYTES: usize = 800 * 1024;
    const MAX_TOTAL_KEY_SIZE_BYTES: usize = 80 * 1024;

    KvConfig {
      max_write_key_size_bytes: self
        .max_write_key_size_bytes
        .unwrap_or(MAX_WRITE_KEY_SIZE_BYTES),
      max_read_key_size_bytes: self
        .max_write_key_size_bytes
        .map(|x|
          // range selectors can contain 0x00 or 0xff suffixes
          x + 1)
        .unwrap_or(MAX_READ_KEY_SIZE_BYTES),
      max_value_size_bytes: self
        .max_value_size_bytes
        .unwrap_or(MAX_VALUE_SIZE_BYTES),
      max_read_ranges: self.max_read_ranges.unwrap_or(MAX_READ_RANGES),
      max_read_entries: self.max_read_entries.unwrap_or(MAX_READ_ENTRIES),
      max_checks: self.max_checks.unwrap_or(MAX_CHECKS),
      max_mutations: self.max_mutations.unwrap_or(MAX_MUTATIONS),
      max_watched_keys: self.max_watched_keys.unwrap_or(MAX_WATCHED_KEYS),
      max_total_mutation_size_bytes: self
        .max_total_mutation_size_bytes
        .unwrap_or(MAX_TOTAL_MUTATION_SIZE_BYTES),
      max_total_key_size_bytes: self
        .max_total_key_size_bytes
        .unwrap_or(MAX_TOTAL_KEY_SIZE_BYTES),
    }
  }
}