···

       
45
       
 
       


     

       
46
       
 
       
  (* Prepare request body if provided *)

     

       
47
       
 
       
  let body_opt = match body with

     

       
48
       
-
       
    | Some json_str -> Some (Requests.Body.of_string Requests.Mime.json json_str)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
    | None -> None

     

       
50
       
 
       
  in

     

       
51
       
 
       


     

···

       
45
       
 
       


     

       
46
       
 
       
  (* Prepare request body if provided *)

     

       
47
       
 
       
  let body_opt = match body with

     

       
48
       
+
       
    | Some body_str ->

     

       
49
       
+
       
        (* Check if this looks like form data (key=value) or JSON *)

     

       
50
       
+
       
        if String.contains body_str '=' && not (String.contains body_str '{') then

     

       
51
       
+
       
          (* Form-encoded data *)

     

       
52
       
+
       
          Some (Requests.Body.of_string Requests.Mime.form body_str)

     

       
53
       
+
       
        else

     

       
54
       
+
       
          (* JSON data *)

     

       
55
       
+
       
          Some (Requests.Body.of_string Requests.Mime.json body_str)

     

       
56
       
 
       
    | None -> None

     

       
57
       
 
       
  in

     

       
58
       
 
       


     

···

       
18
       
 
       
    dirty_keys = [];

     

       
19
       
 
       
  }

     

       
20
       
 
       


     

       
21
       
-
       
(* Helper to encode storage data as JSON *)

     

       
22
       
 
       
let encode_storage_update keys_values =

     

       
0
       
 
       

     

       
23
       
 
       
  let storage_obj =

     

       
24
       
 
       
    List.map (fun (k, v) -> (k, `String v)) keys_values

     

       
25
       
 
       
  in

     

       
26
       
-
       
  let json_obj = `O [("storage", `O storage_obj)] in

     

       
27
       
-
       
  (* Convert to JSON string *)

     

       
0
       
 
       

     

       
28
       
 
       
  let encoder = Jsonm.encoder (`Buffer (Buffer.create 256)) in

     

       
29
       
 
       
  let rec encode_json encoder json =

     

       
30
       
 
       
    match json with

     
···

       
46
       
 
       
  in

     

       
47
       
 
       
  encode_json encoder json_obj;

     

       
48
       
 
       
  ignore (Jsonm.encode encoder `End);

     

       
49
       
-
       
  match Jsonm.encoder_dst encoder with

     

       
50
       
-
       
  | `Buffer buf -> Buffer.contents buf

     

       
51
       
-
       
  | _ -> ""

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
52
       
 
       


     

       
53
       
 
       
let get t ~key =

     

       
54
       
 
       
  Log.debug (fun m -> m "Getting value for key: %s" key);

     
···

       
85
       
 
       
          None

     

       
86
       
 
       


     

       
87
       
 
       
let put t ~key ~value =

     

       
88
       
-
       
  Log.debug (fun m -> m "Storing key: %s" key);

     

       
89
       
 
       
  (* Update cache *)

     

       
90
       
 
       
  Hashtbl.replace t.cache key value;

     

       
91
       
 
       


     
···

       
93
       
 
       
  if not (List.mem key t.dirty_keys) then

     

       
94
       
 
       
    t.dirty_keys <- key :: t.dirty_keys;

     

       
95
       
 
       


     

       
96
       
-
       
  (* Send update to Zulip API *)

     

       
97
       
 
       
  let body = encode_storage_update [(key, value)] in

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
98
       
 
       
  match Zulip.Client.request t.client

     

       
99
       
 
       
          ~method_:`PUT

     

       
100
       
 
       
          ~path:"/api/v1/bot_storage"

     
···

       
165
       
 
       
    if updates = [] then

     

       
166
       
 
       
      Ok ()

     

       
167
       
 
       
    else

     

       
0
       
 
       

     

       
168
       
 
       
      let body = encode_storage_update updates in

     

       
0
       
 
       

     

       
169
       
 
       
      match Zulip.Client.request t.client

     

       
170
       
 
       
              ~method_:`PUT

     

       
171
       
 
       
              ~path:"/api/v1/bot_storage"

     

···

       
18
       
 
       
    dirty_keys = [];

     

       
19
       
 
       
  }

     

       
20
       
 
       


     

       
21
       
+
       
(* Helper to encode storage data as form-encoded body for the API *)

     

       
22
       
 
       
let encode_storage_update keys_values =

     

       
23
       
+
       
  (* Build the storage object - just the key-value pairs, not wrapped in "storage" *)

     

       
24
       
 
       
  let storage_obj =

     

       
25
       
 
       
    List.map (fun (k, v) -> (k, `String v)) keys_values

     

       
26
       
 
       
  in

     

       
27
       
+
       
  let json_obj = `O storage_obj in

     

       
28
       
+
       


     

       
29
       
+
       
  (* Convert to JSON string using Jsonm *)

     

       
30
       
 
       
  let encoder = Jsonm.encoder (`Buffer (Buffer.create 256)) in

     

       
31
       
 
       
  let rec encode_json encoder json =

     

       
32
       
 
       
    match json with

     
···

       
48
       
 
       
  in

     

       
49
       
 
       
  encode_json encoder json_obj;

     

       
50
       
 
       
  ignore (Jsonm.encode encoder `End);

     

       
51
       
+
       


     

       
52
       
+
       
  let json_str = match Jsonm.encoder_dst encoder with

     

       
53
       
+
       
    | `Buffer buf -> Buffer.contents buf

     

       
54
       
+
       
    | _ -> "{}"

     

       
55
       
+
       
  in

     

       
56
       
+
       


     

       
57
       
+
       
  (* Return as form-encoded body: storage=<url-encoded-json> *)

     

       
58
       
+
       
  "storage=" ^ Uri.pct_encode json_str

     

       
59
       
 
       


     

       
60
       
 
       
let get t ~key =

     

       
61
       
 
       
  Log.debug (fun m -> m "Getting value for key: %s" key);

     
···

       
92
       
 
       
          None

     

       
93
       
 
       


     

       
94
       
 
       
let put t ~key ~value =

     

       
95
       
+
       
  Log.debug (fun m -> m "Storing key: %s with value: %s" key value);

     

       
96
       
 
       
  (* Update cache *)

     

       
97
       
 
       
  Hashtbl.replace t.cache key value;

     

       
98
       
 
       


     
···

       
100
       
 
       
  if not (List.mem key t.dirty_keys) then

     

       
101
       
 
       
    t.dirty_keys <- key :: t.dirty_keys;

     

       
102
       
 
       


     

       
103
       
+
       
  (* Use the helper to properly encode as form data *)

     

       
104
       
 
       
  let body = encode_storage_update [(key, value)] in

     

       
105
       
+
       


     

       
106
       
+
       
  Log.debug (fun m -> m "Sending storage update with body: %s" body);

     

       
107
       
+
       


     

       
108
       
 
       
  match Zulip.Client.request t.client

     

       
109
       
 
       
          ~method_:`PUT

     

       
110
       
 
       
          ~path:"/api/v1/bot_storage"

     
···

       
175
       
 
       
    if updates = [] then

     

       
176
       
 
       
      Ok ()

     

       
177
       
 
       
    else

     

       
178
       
+
       
      (* Use the helper to properly encode all updates as form data *)

     

       
179
       
 
       
      let body = encode_storage_update updates in

     

       
180
       
+
       


     

       
181
       
 
       
      match Zulip.Client.request t.client

     

       
182
       
 
       
              ~method_:`PUT

     

       
183
       
 
       
              ~path:"/api/v1/bot_storage"