commit 68a0e57b8d1064d71d4087f5dfd0da5d78e468f7 · anil.recoil.org/slop

+3 -3

stack/zulip/examples/atom_feed_bot.ml

···

       179
       179
        
           in

     

       180
       180
        
           match Zulip.Messages.send client message with

     

       181
       181
        
           | Ok _ -> Printf.printf "Posted: %s\n" entry.title

     

       182
       182
       -
           | Error e -> Printf.eprintf "Error posting: %s\n" (Zulip.Zerror.message e)

     

       182
       182
       +
           | Error e -> Printf.eprintf "Error posting: %s\n" (Zulip.error_message e)

     

       183
       183
        
       

     

       184
       184
        
         let process_feed client state (url, channel, topic) =

     

       185
       185
        
           Printf.printf "Processing feed: %s -> #%s/%s\n" url channel topic;

     
···

       208
       208
        
           let auth = match Zulip.Auth.from_zuliprc () with

     

       209
       209
        
             | Ok a -> a

     

       210
       210
        
             | Error e ->

     

       211
       211
       -
                 Printf.eprintf "Failed to load auth: %s\n" (Zulip.Zerror.message e);

     

       211
       211
       +
                 Printf.eprintf "Failed to load auth: %s\n" (Zulip.error_message e);

     

       212
       212
        
                 exit 1

     

       213
       213
        
           in

     

       214
       214
        
       

     
···

       352
       352
        
         let auth = match Zulip.Auth.from_zuliprc () with

     

       353
       353
        
           | Ok a -> a

     

       354
       354
        
           | Error e ->

     

       355
       355
       -
               Log.err (fun m -> m "Failed to load auth: %s" (Zulip.Zerror.message e));

     

       355
       355
       +
               Log.err (fun m -> m "Failed to load auth: %s" (Zulip.error_message e));

     

       356
       356
        
               exit 1

     

       357
       357
        
         in

     

       358
       358

+1 -1

stack/zulip/examples/bot_example.ml

···

       38
       38
        
                 | `O fields -> String.concat ", " (List.map fst fields)

     

       39
       39
        
                 | _ -> "unknown format")

     

       40
       40
        
          | Error err ->

     

       41
       41
       -
              Printf.printf "❌ API request failed: %s\n" (Zulip.Zerror.message err));

     

       41
       41
       +
              Printf.printf "❌ API request failed: %s\n" (Zulip.error_message err));

     

       42
       42
        
         

     

       43
       43
        
         Printf.printf "\n🎉 Bot example completed successfully!\n";

     

       44
       44
        
         Printf.printf "Note: This uses mock responses since we're not connected to a real Zulip server.\n"

+11 -11

stack/zulip/examples/echo_bot.ml

···

       73
       73
        
                              Log.info (fun m -> m "Stored key=%s value=%s for user %s" key value sender_name);

     

       74
       74
        
                              Printf.sprintf "✅ Stored: `%s` = `%s`" key value

     

       75
       75
        
                          | Error e ->

     

       76
       76
       -
                              Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.Zerror.message e));

     

       77
       77
       -
                              Printf.sprintf "❌ Failed to store: %s" (Zulip.Zerror.message e))

     

       76
       76
       +
                              Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.error_message e));

     

       77
       77
       +
                              Printf.sprintf "❌ Failed to store: %s" (Zulip.error_message e))

     

       78
       78
        
                     | None ->

     

       79
       79
        
                         "Usage: `store <key> <value>` - Example: `store name John`"

     

       80
       80
        
                   )

     
···

       97
       97
        
                         Log.info (fun m -> m "Deleted key=%s for user %s" key sender_name);

     

       98
       98
        
                         Printf.sprintf "🗑️ Deleted key: `%s`" key

     

       99
       99
        
                     | Error e ->

     

       100
       100
       -
                         Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.Zerror.message e));

     

       101
       101
       -
                         Printf.sprintf "❌ Failed to delete: %s" (Zulip.Zerror.message e)

     

       100
       100
       +
                         Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.error_message e));

     

       101
       101
       +
                         Printf.sprintf "❌ Failed to delete: %s" (Zulip.error_message e)

     

       102
       102
        
                   )

     

       103
       103
        
                   else if lower_msg = "list" then (

     

       104
       104
        
                     (* List all stored keys *)

     
···

       109
       109
        
                         let key_list = String.concat "\n" (List.map (fun k -> "• `" ^ k ^ "`") keys) in

     

       110
       110
        
                         Printf.sprintf "📋 Stored keys:\n%s\n\nUse `get <key>` to retrieve values." key_list

     

       111
       111
        
                     | Error e ->

     

       112
       112
       -
                         Printf.sprintf "❌ Failed to list keys: %s" (Zulip.Zerror.message e)

     

       112
       112
       +
                         Printf.sprintf "❌ Failed to list keys: %s" (Zulip.error_message e)

     

       113
       113
        
                   )

     

       114
       114
        
                   else

     

       115
       115
        
                     Printf.sprintf "Echo from %s: %s" sender_name cleaned_msg

     
···

       162
       162
        
                              Log.info (fun m -> m "Stored key=%s value=%s for user %s" key value sender_name);

     

       163
       163
        
                              Printf.sprintf "✅ Stored: `%s` = `%s`" key value

     

       164
       164
        
                          | Error e ->

     

       165
       165
       -
                              Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.Zerror.message e));

     

       166
       166
       -
                              Printf.sprintf "❌ Failed to store: %s" (Zulip.Zerror.message e))

     

       165
       165
       +
                              Log.err (fun m -> m "Failed to store key=%s: %s" key (Zulip.error_message e));

     

       166
       166
       +
                              Printf.sprintf "❌ Failed to store: %s" (Zulip.error_message e))

     

       167
       167
        
                     | None ->

     

       168
       168
        
                         "Usage: `store <key> <value>` - Example: `store name John`"

     

       169
       169
        
                   )

     
···

       186
       186
        
                         Log.info (fun m -> m "Deleted key=%s for user %s" key sender_name);

     

       187
       187
        
                         Printf.sprintf "🗑️ Deleted key: `%s`" key

     

       188
       188
        
                     | Error e ->

     

       189
       189
       -
                         Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.Zerror.message e));

     

       190
       190
       -
                         Printf.sprintf "❌ Failed to delete: %s" (Zulip.Zerror.message e)

     

       189
       189
       +
                         Log.err (fun m -> m "Failed to delete key=%s: %s" key (Zulip.error_message e));

     

       190
       190
       +
                         Printf.sprintf "❌ Failed to delete: %s" (Zulip.error_message e)

     

       191
       191
        
                   )

     

       192
       192
        
                   else if lower_msg = "list" then (

     

       193
       193
        
                     (* List all stored keys *)

     
···

       198
       198
        
                         let key_list = String.concat "\n" (List.map (fun k -> "• `" ^ k ^ "`") keys) in

     

       199
       199
        
                         Printf.sprintf "📋 Stored keys:\n%s\n\nUse `get <key>` to retrieve values." key_list

     

       200
       200
        
                     | Error e ->

     

       201
       201
       -
                         Printf.sprintf "❌ Failed to list keys: %s" (Zulip.Zerror.message e)

     

       201
       201
       +
                         Printf.sprintf "❌ Failed to list keys: %s" (Zulip.error_message e)

     

       202
       202
        
                   )

     

       203
       203
        
                   else

     

       204
       204
        
                     Printf.sprintf "Echo from %s: %s" sender_name cleaned_msg

     
···

       237
       237
        
               Log.info (fun m -> m "Server: %s" (Zulip.Auth.server_url a));

     

       238
       238
        
               a

     

       239
       239
        
           | Error e ->

     

       240
       240
       -
               Log.err (fun m -> m "Failed to load .zuliprc: %s" (Zulip.Zerror.message e));

     

       240
       240
       +
               Log.err (fun m -> m "Failed to load .zuliprc: %s" (Zulip.error_message e));

     

       241
       241
        
               Log.app (fun m -> m "\nPlease create a ~/.zuliprc file with:");

     

       242
       242
        
               Log.app (fun m -> m "[api]");

     

       243
       243
        
               Log.app (fun m -> m "email=bot@example.com");

+3 -3

stack/zulip/examples/test_client.ml

···

       9
       9
        
             Printf.printf "  Email: %s\n" (Zulip.Auth.email auth);

     

       10
       10
        
             auth

     

       11
       11
        
         | Error e ->

     

       12
       12
       -
             Printf.eprintf "Failed to load auth: %s\n" (Zulip.Zerror.message e);

     

       12
       12
       +
             Printf.eprintf "Failed to load auth: %s\n" (Zulip.error_message e);

     

       13
       13
        
             (* Create a test auth *)

     

       14
       14
        
             Zulip.Auth.create

     

       15
       15
        
               ~server_url:"https://example.zulipchat.com"

     
···

       36
       36
        
             Printf.printf "Message sent successfully!\n";

     

       37
       37
        
             Printf.printf "Message ID: %d\n" (Zulip.Message_response.id response)

     

       38
       38
        
         | Error e ->

     

       39
       39
       -
             Printf.eprintf "Failed to send message: %s\n" (Zulip.Zerror.message e)

     

       39
       39
       +
             Printf.eprintf "Failed to send message: %s\n" (Zulip.error_message e)

     

       40
       40
        
       

     

       41
       41
        
       let test_fetch_messages env auth =

     

       42
       42
        
         Printf.printf "\nTesting message fetch...\n";

     
···

       55
       55
        
                   | _ -> Printf.printf "No messages field found\n")

     

       56
       56
        
              | _ -> Printf.printf "Unexpected JSON format\n")

     

       57
       57
        
         | Error e ->

     

       58
       58
       -
             Printf.eprintf "Failed to fetch messages: %s\n" (Zulip.Zerror.message e)

     

       58
       58
       +
             Printf.eprintf "Failed to fetch messages: %s\n" (Zulip.error_message e)

     

       59
       59
        
       

     

       60
       60
        
       let () =

     

       61
       61
        
         Printf.printf "Zulip OCaml Client Test\n";

+2 -2

stack/zulip/examples/test_realtime_bot.ml

···

       36
       36
        
       

     

       37
       37
        
           (match Bot_storage.put storage ~key:test_key ~value:test_value with

     

       38
       38
        
            | Ok () -> Log.info (fun m -> m "Stored message in bot storage")

     

       39
       39
       -
            | Error e -> Log.err (fun m -> m "Storage error: %s" (Zulip.Zerror.message e)));

     

       39
       39
       +
            | Error e -> Log.err (fun m -> m "Storage error: %s" (Zulip.error_message e)));

     

       40
       40
        
       

     

       41
       41
        
           (* Always reply with confirmation *)

     

       42
       42
        
           let reply = Printf.sprintf "Test bot received: %s"

     
···

       62
       62
        
               Log.info (fun m -> m "Server: %s" (Zulip.Auth.server_url a));

     

       63
       63
        
               a

     

       64
       64
        
           | Error e ->

     

       65
       65
       -
               Log.err (fun m -> m "Failed to load .zuliprc: %s" (Zulip.Zerror.message e));

     

       65
       65
       +
               Log.err (fun m -> m "Failed to load .zuliprc: %s" (Zulip.error_message e));

     

       66
       66
        
               exit 1

     

       67
       67
        
         in

     

       68
       68

+3 -3

stack/zulip/lib/zulip/lib/auth.ml

···

       65
       65
        
               in

     

       66
       66
        
               Ok { server_url; email; api_key }

     

       67
       67
        
           | _ ->

     

       68
       68
       -
               Error (Zerror.create ~code:(Other "config_missing")

     

       68
       68
       +
               Error (Zulip_types.create_error ~code:(Other "config_missing")

     

       69
       69
        
                       ~msg:"Missing required fields: email, key, site in zuliprc" ())

     

       70
       70
        
         with

     

       71
       71
        
         | Sys_error msg ->

     

       72
       72
       -
             Error (Zerror.create ~code:(Other "file_error") ~msg:("Cannot read zuliprc file: " ^ msg) ())

     

       72
       72
       +
             Error (Zulip_types.create_error ~code:(Other "file_error") ~msg:("Cannot read zuliprc file: " ^ msg) ())

     

       73
       73
        
         | exn ->

     

       74
       74
       -
             Error (Zerror.create ~code:(Other "parse_error") ~msg:("Error parsing zuliprc: " ^ Printexc.to_string exn) ())

     

       74
       74
       +
             Error (Zulip_types.create_error ~code:(Other "parse_error") ~msg:("Error parsing zuliprc: " ^ Printexc.to_string exn) ())

     

       75
       75
        
       

     

       76
       76
        
       let server_url t = t.server_url

     

       77
       77
        
       let email t = t.email

+1 -1

stack/zulip/lib/zulip/lib/auth.mli

···

       1
       1
        
       type t

     

       2
       2
        
       

     

       3
       3
        
       val create : server_url:string -> email:string -> api_key:string -> t

     

       4
       4
       -
       val from_zuliprc : ?path:string -> unit -> (t, Zerror.t) result

     

       4
       4
       +
       val from_zuliprc : ?path:string -> unit -> (t, Zulip_types.zerror) result

     

       5
       5
        
       val server_url : t -> string

     

       6
       6
        
       val email : t -> string

     

       7
       7
        
       val to_basic_auth_header : t -> string

+2 -2

stack/zulip/lib/zulip/lib/channel.ml

···

       42
       42
        
               

     

       43
       43
        
               Ok { name; description; invite_only; history_public_to_subscribers }

     

       44
       44
        
           | _ -> 

     

       45
       45
       -
               Error (Zerror.create ~code:(Other "json_parse_error") ~msg:"Channel JSON must be an object" ())

     

       45
       45
       +
               Error (Zulip_types.create_error ~code:(Other "json_parse_error") ~msg:"Channel JSON must be an object" ())

     

       46
       46
        
         with

     

       47
       47
        
         | exn ->

     

       48
       48
       -
             Error (Zerror.create ~code:(Other "json_parse_error") ~msg:("Channel JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       48
       48
       +
             Error (Zulip_types.create_error ~code:(Other "json_parse_error") ~msg:("Channel JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       49
       49
        
       

     

       50
       50
        
       let pp fmt t = Format.fprintf fmt "Channel{name=%s, description=%s}" t.name t.description

+2 -2

stack/zulip/lib/zulip/lib/channel.mli

···

       11
       11
        
       val description : t -> string

     

       12
       12
        
       val invite_only : t -> bool

     

       13
       13
        
       val history_public_to_subscribers : t -> bool

     

       14
       14
       -
       val to_json : t -> Zerror.json

     

       15
       15
       -
       val of_json : Zerror.json -> (t, Zerror.t) result

     

       14
       14
       +
       val to_json : t -> Zulip_types.json

     

       15
       15
       +
       val of_json : Zulip_types.json -> (t, Zulip_types.zerror) result

     

       16
       16
        
       val pp : Format.formatter -> t -> unit

+2 -2

stack/zulip/lib/zulip/lib/channels.ml

···

       31
       31
        
                         | Error _ -> acc

     

       32
       32
        
                       ) [] channel_list in

     

       33
       33
        
                       Ok (List.rev channels)

     

       34
       34
       -
                   | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Invalid streams response format" ()))

     

       35
       35
       -
              | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Streams response must be an object" ()))

     

       34
       34
       +
                   | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Invalid streams response format" ()))

     

       35
       35
       +
              | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Streams response must be an object" ()))

     

       36
       36
        
         | Error err -> Error err

     

       37
       37
        
       

     

       38
       38
        
       let subscribe client ~channels =

+5 -5

stack/zulip/lib/zulip/lib/channels.mli

···

       1
       1
       -
       val create_channel : Client.t -> Channel.t -> (unit, Zerror.t) result

     

       2
       2
       -
       val delete : Client.t -> name:string -> (unit, Zerror.t) result

     

       3
       3
       -
       val list : Client.t -> (Channel.t list, Zerror.t) result

     

       4
       4
       -
       val subscribe : Client.t -> channels:string list -> (unit, Zerror.t) result

     

       5
       5
       -
       val unsubscribe : Client.t -> channels:string list -> (unit, Zerror.t) result
     

       1
       1
       +
       val create_channel : Client.t -> Channel.t -> (unit, Zulip_types.zerror) result

     

       2
       2
       +
       val delete : Client.t -> name:string -> (unit, Zulip_types.zerror) result

     

       3
       3
       +
       val list : Client.t -> (Channel.t list, Zulip_types.zerror) result

     

       4
       4
       +
       val subscribe : Client.t -> channels:string list -> (unit, Zulip_types.zerror) result

     

       5
       5
       +
       val unsubscribe : Client.t -> channels:string list -> (unit, Zulip_types.zerror) result

+6 -6

stack/zulip/lib/zulip/lib/client.ml

···

       134
       134
        
                    | _ -> "Unknown error"

     

       135
       135
        
                  in

     

       136
       136
        
                  let code = match List.assoc_opt "code" fields with

     

       137
       137
       -
                    | Some (`String s) -> Zerror.code_of_string s

     

       138
       138
       -
                    | _ -> Zerror.Other "unknown"

     

       137
       137
       +
                    | Some (`String s) -> Zulip_types.error_code_of_string s

     

       138
       138
       +
                    | _ -> Zulip_types.Other "unknown"

     

       139
       139
        
                  in

     

       140
       140
        
                  Log.warn (fun m -> m "API error: %s (code: %s)" msg

     

       141
       141
       -
                    (Zerror.code_to_string code));

     

       142
       142
       -
                  Error (Zerror.create ~code ~msg ())

     

       141
       141
       +
                    (Zulip_types.error_code_to_string code));

     

       142
       142
       +
                  Error (Zulip_types.create_error ~code ~msg ())

     

       143
       143
        
              | _ ->

     

       144
       144
        
                  if status >= 200 && status < 300 then

     

       145
       145
        
                    Ok json

     

       146
       146
        
                  else

     

       147
       147
        
                    (Log.warn (fun m -> m "HTTP error: %d" status);

     

       148
       148
       -
                   Error (Zerror.create ~code:(Zerror.Other (string_of_int status))

     

       148
       148
       +
                   Error (Zulip_types.create_error ~code:(Zulip_types.Other (string_of_int status))

     

       149
       149
        
                             ~msg:("HTTP error: " ^ string_of_int status) ())))

     

       150
       150
        
         | _ ->

     

       151
       151
        
             if status >= 200 && status < 300 then

     

       152
       152
        
               Ok json

     

       153
       153
        
             else

     

       154
       154
        
               (Log.err (fun m -> m "Invalid JSON response");

     

       155
       155
       -
                Error (Zerror.create ~code:(Zerror.Other "json_parse")

     

       155
       155
       +
                Error (Zulip_types.create_error ~code:(Zulip_types.Other "json_parse")

     

       156
       156
        
                        ~msg:"Invalid JSON response" ()))

     

       157
       157
        
       

     

       158
       158
        
       let pp fmt t =

+1 -1

stack/zulip/lib/zulip/lib/client.mli

···

       24
       24
        
         ?params:(string * string) list ->

     

       25
       25
        
         ?body:string ->

     

       26
       26
        
         unit ->

     

       27
       27
       -
         (Zerror.json, Zerror.t) result

     

       27
       27
       +
         (Zulip_types.json, Zulip_types.zerror) result

     

       28
       28
        
       (** Make an HTTP request to the Zulip API using the requests library *)

     

       29
       29
        
       

     

       30
       30
        
       val pp : Format.formatter -> t -> unit

+3 -3

stack/zulip/lib/zulip/lib/event.ml

···

       1
       1
        
       type t = {

     

       2
       2
        
         id : int;

     

       3
       3
        
         type_ : Event_type.t;

     

       4
       4
       -
         data : Zerror.json;

     

       4
       4
       +
         data : Zulip_types.json;

     

       5
       5
        
       }

     

       6
       6
        
       

     

       7
       7
        
       let id t = t.id

     
···

       28
       28
        
       

     

       29
       29
        
               Ok { id; type_; data }

     

       30
       30
        
           | _ -> 

     

       31
       31
       -
               Error (Zerror.create ~code:(Other "json_parse_error") ~msg:"Event JSON must be an object" ())

     

       31
       31
       +
               Error (Zulip_types.create_error ~code:(Other "json_parse_error") ~msg:"Event JSON must be an object" ())

     

       32
       32
        
         with

     

       33
       33
        
         | exn ->

     

       34
       34
       -
             Error (Zerror.create ~code:(Other "json_parse_error") ~msg:("Event JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       34
       34
       +
             Error (Zulip_types.create_error ~code:(Other "json_parse_error") ~msg:("Event JSON parsing failed: " ^ Printexc.to_string exn) ())

     

       35
       35
        
       

     

       36
       36
        
       let pp fmt t = Format.fprintf fmt "Event{id=%d, type=%a}" t.id Event_type.pp t.type_

+2 -2

stack/zulip/lib/zulip/lib/event.mli

···

       2
       2
        
       

     

       3
       3
        
       val id : t -> int

     

       4
       4
        
       val type_ : t -> Event_type.t

     

       5
       5
       -
       val data : t -> Zerror.json

     

       6
       6
       -
       val of_json : Zerror.json -> (t, Zerror.t) result

     

       5
       5
       +
       val data : t -> Zulip_types.json

     

       6
       6
       +
       val of_json : Zulip_types.json -> (t, Zulip_types.zerror) result

     

       7
       7
        
       val pp : Format.formatter -> t -> unit

+5 -5

stack/zulip/lib/zulip/lib/event_queue.ml

···

       23
       23
        
              | `O fields ->

     

       24
       24
        
                  (match List.assoc_opt "queue_id" fields with

     

       25
       25
        
                   | Some (`String queue_id) -> Ok { id = queue_id }

     

       26
       26
       -
                   | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Invalid register response: missing queue_id" ()))

     

       27
       27
       -
              | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Register response must be an object" ()))

     

       26
       26
       +
                   | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Invalid register response: missing queue_id" ()))

     

       27
       27
       +
              | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Register response must be an object" ()))

     

       28
       28
        
         | Error err -> Error err

     

       29
       29
        
       

     

       30
       30
        
       let id t = t.id

     
···

       45
       45
        
                         match Event.of_json event_json with

     

       46
       46
        
                         | Ok event -> event :: acc

     

       47
       47
        
                         | Error e ->

     

       48
       48
       -
                             Log.warn (fun m -> m "Failed to parse event: %s" (Zerror.message e));

     

       48
       48
       +
                             Log.warn (fun m -> m "Failed to parse event: %s" (Zulip_types.error_message e));

     

       49
       49
        
                             acc

     

       50
       50
        
                       ) [] event_list in

     

       51
       51
        
                       Ok (List.rev events)

     

       52
       52
        
                   | Some _other ->

     

       53
       53
        
                       Log.warn (fun m -> m "Events field is not an array");

     

       54
       54
       -
                       Error (Zerror.create ~code:(Other "api_error") ~msg:"Invalid events response format" ())

     

       54
       54
       +
                       Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Invalid events response format" ())

     

       55
       55
        
                   | None ->

     

       56
       56
        
                       Log.debug (fun m -> m "No events field in response");

     

       57
       57
        
                       Ok [])

     

       58
       58
       -
              | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Events response must be an object" ()))

     

       58
       58
       +
              | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Events response must be an object" ()))

     

       59
       59
        
         | Error err -> Error err

     

       60
       60
        
       

     

       61
       61
        
       let delete t client =

+3 -3

stack/zulip/lib/zulip/lib/event_queue.mli

···

       4
       4
        
         Client.t ->

     

       5
       5
        
         ?event_types:Event_type.t list ->

     

       6
       6
        
         unit ->

     

       7
       7
       -
         (t, Zerror.t) result

     

       7
       7
       +
         (t, Zulip_types.zerror) result

     

       8
       8
        
       

     

       9
       9
        
       val id : t -> string

     

       10
       10
       -
       val get_events : t -> Client.t -> ?last_event_id:int -> unit -> (Event.t list, Zerror.t) result

     

       11
       11
       -
       val delete : t -> Client.t -> (unit, Zerror.t) result

     

       10
       10
       +
       val get_events : t -> Client.t -> ?last_event_id:int -> unit -> (Event.t list, Zulip_types.zerror) result

     

       11
       11
       +
       val delete : t -> Client.t -> (unit, Zulip_types.zerror) result

     

       12
       12
        
       val pp : Format.formatter -> t -> unit

+21 -23

stack/zulip/lib/zulip/lib/jsonu.ml

···

       1
       1
        
       (** JSON utility functions for Zulip API *)

     

       2
       2
        
       

     

       3
       3
       -
       open Zerror

     

       4
       4
       -
       

     

       5
       5
       -
       type json = Zerror.json

     

       3
       3
       +
       type json = Zulip_types.json

     

       6
       4
        
       

     

       7
       5
        
       (** {1 Field extraction utilities} *)

     

       8
       6
        
       

     

       9
       7
        
       let get_string fields key =

     

       10
       8
        
         match List.assoc_opt key fields with

     

       11
       9
        
         | Some (`String s) -> Ok s

     

       12
       12
       -
         | Some _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a string" key) ())

     

       13
       13
       -
         | None -> Error (Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       10
       10
       +
         | Some _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a string" key) ())

     

       11
       11
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       14
       12
        
       

     

       15
       13
        
       let get_string_default fields key default =

     

       16
       14
        
         match get_string fields key with

     
···

       36
       34
        
         match List.assoc_opt key fields with

     

       37
       35
        
         | Some json ->

     

       38
       36
        
             (try Ok (to_int_flex json) with

     

       39
       39
       -
              | Failure msg -> Error (Zerror.create ~code:(Other "json_type_error") ~msg ()))

     

       40
       40
       -
         | None -> Error (Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       37
       37
       +
              | Failure msg -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg ()))

     

       38
       38
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       41
       39
        
       

     

       42
       40
        
       let get_int_default fields key default =

     

       43
       41
        
         match get_int fields key with

     
···

       54
       52
        
         | Some (`Float f) -> Ok f

     

       55
       53
        
         | Some (`String s) ->

     

       56
       54
        
             (try Ok (float_of_string s) with

     

       57
       57
       -
              | _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a valid float" key) ()))

     

       58
       58
       -
         | Some _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a float" key) ())

     

       59
       59
       -
         | None -> Error (Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       55
       55
       +
              | _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a valid float" key) ()))

     

       56
       56
       +
         | Some _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a float" key) ())

     

       57
       57
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       60
       58
        
       

     

       61
       59
        
       let get_float_default fields key default =

     

       62
       60
        
         match get_float fields key with

     
···

       66
       64
        
       let get_bool fields key =

     

       67
       65
        
         match List.assoc_opt key fields with

     

       68
       66
        
         | Some (`Bool b) -> Ok b

     

       69
       69
       -
         | Some _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a boolean" key) ())

     

       70
       70
       -
         | None -> Error (Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       67
       67
       +
         | Some _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not a boolean" key) ())

     

       68
       68
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       71
       69
        
       

     

       72
       70
        
       let get_bool_default fields key default =

     

       73
       71
        
         match get_bool fields key with

     
···

       82
       80
        
       let get_object fields key =

     

       83
       81
        
         match List.assoc_opt key fields with

     

       84
       82
        
         | Some (`O obj) -> Ok obj

     

       85
       85
       -
         | Some _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not an object" key) ())

     

       86
       86
       -
         | None -> Error (Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       83
       83
       +
         | Some _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not an object" key) ())

     

       84
       84
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       87
       85
        
       

     

       88
       86
        
       let get_object_opt fields key =

     

       89
       87
        
         match List.assoc_opt key fields with

     
···

       93
       91
        
       let get_array fields key =

     

       94
       92
        
         match List.assoc_opt key fields with

     

       95
       93
        
         | Some (`A arr) -> Ok arr

     

       96
       96
       -
         | Some _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not an array" key) ())

     

       97
       97
       -
         | None -> Error (Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       94
       94
       +
         | Some _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' is not an array" key) ())

     

       95
       95
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Field '%s' not found" key) ())

     

       98
       96
        
       

     

       99
       97
        
       let get_array_opt fields key =

     

       100
       98
        
         match List.assoc_opt key fields with

     
···

       125
       123
        
       

     

       126
       124
        
       let with_object context f = function

     

       127
       125
        
         | `O fields -> f fields

     

       128
       128
       -
         | _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "%s: expected JSON object" context) ())

     

       126
       126
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "%s: expected JSON object" context) ())

     

       129
       127
        
       

     

       130
       128
        
       let with_array context f json =

     

       131
       129
        
         match json with

     
···

       138
       136
        
                   | Error e -> Error e

     

       139
       137
        
             in

     

       140
       138
        
             process [] items

     

       141
       141
       -
         | _ -> Error (Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "%s: expected JSON array" context) ())

     

       139
       139
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "%s: expected JSON array" context) ())

     

       142
       140
        
       

     

       143
       141
        
       (** {1 Construction utilities} *)

     

       144
       142
        
       

     
···

       158
       156
        
       (** {1 Error handling} *)

     

       159
       157
        
       

     

       160
       158
        
       let json_error msg =

     

       161
       161
       -
         Zerror.create ~code:(Other "json_error") ~msg ()

     

       159
       159
       +
         Zulip_types.create_error ~code:(Other "json_error") ~msg ()

     

       162
       160
        
       

     

       163
       161
        
       let field_missing_error field =

     

       164
       164
       -
         Zerror.create ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Required field '%s' not found" field) ()

     

       162
       162
       +
         Zulip_types.create_error ~code:(Other "json_missing_field") ~msg:(Printf.sprintf "Required field '%s' not found" field) ()

     

       165
       163
        
       

     

       166
       164
        
       let type_mismatch_error field expected =

     

       167
       167
       -
         Zerror.create ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' type mismatch: expected %s" field expected) ()

     

       165
       165
       +
         Zulip_types.create_error ~code:(Other "json_type_error") ~msg:(Printf.sprintf "Field '%s' type mismatch: expected %s" field expected) ()

     

       168
       166
        
       

     

       169
       167
        
       let parse_with_error context f =

     

       170
       168
        
         try f ()

     

       171
       169
        
         with

     

       172
       172
       -
         | Failure msg -> Error (Zerror.create ~code:(Other "json_parse_error") ~msg:(Printf.sprintf "%s: %s" context msg) ())

     

       173
       173
       -
         | exn -> Error (Zerror.create ~code:(Other "json_parse_error") ~msg:(Printf.sprintf "%s: %s" context (Printexc.to_string exn)) ())

     

       170
       170
       +
         | Failure msg -> Error (Zulip_types.create_error ~code:(Other "json_parse_error") ~msg:(Printf.sprintf "%s: %s" context msg) ())

     

       171
       171
       +
         | exn -> Error (Zulip_types.create_error ~code:(Other "json_parse_error") ~msg:(Printf.sprintf "%s: %s" context (Printexc.to_string exn)) ())

     

       174
       172
        
       

     

       175
       173
        
       

     

       176
       174
        
       (** {1 Debugging utilities} *)

+13 -13

stack/zulip/lib/zulip/lib/jsonu.mli

···

       5
       5
        
       

     

       6
       6
        
       (** {1 Type definitions} *)

     

       7
       7
        
       

     

       8
       8
       -
       type json = Zerror.json

     

       8
       8
       +
       type json = Zulip_types.json

     

       9
       9
        
       

     

       10
       10
        
       (** {1 Field extraction utilities} *)

     

       11
       11
        
       

     

       12
       12
        
       (** Extract a string field from a JSON object *)

     

       13
       13
       -
       val get_string : (string * json) list -> string -> (string, Zerror.t) result

     

       13
       13
       +
       val get_string : (string * json) list -> string -> (string, Zulip_types.zerror) result

     

       14
       14
        
       

     

       15
       15
        
       (** Extract a string field with a default value *)

     

       16
       16
        
       val get_string_default : (string * json) list -> string -> string -> string

     
···

       19
       19
        
       val get_string_opt : (string * json) list -> string -> string option

     

       20
       20
        
       

     

       21
       21
        
       (** Extract an integer field (handles both int and float representations) *)

     

       22
       22
       -
       val get_int : (string * json) list -> string -> (int, Zerror.t) result

     

       22
       22
       +
       val get_int : (string * json) list -> string -> (int, Zulip_types.zerror) result

     

       23
       23
        
       

     

       24
       24
        
       (** Extract an integer field with a default value *)

     

       25
       25
        
       val get_int_default : (string * json) list -> string -> int -> int

     
···

       28
       28
        
       val get_int_opt : (string * json) list -> string -> int option

     

       29
       29
        
       

     

       30
       30
        
       (** Extract a float field *)

     

       31
       31
       -
       val get_float : (string * json) list -> string -> (float, Zerror.t) result

     

       31
       31
       +
       val get_float : (string * json) list -> string -> (float, Zulip_types.zerror) result

     

       32
       32
        
       

     

       33
       33
        
       (** Extract a float field with a default value *)

     

       34
       34
        
       val get_float_default : (string * json) list -> string -> float -> float

     

       35
       35
        
       

     

       36
       36
        
       (** Extract a boolean field *)

     

       37
       37
       -
       val get_bool : (string * json) list -> string -> (bool, Zerror.t) result

     

       37
       37
       +
       val get_bool : (string * json) list -> string -> (bool, Zulip_types.zerror) result

     

       38
       38
        
       

     

       39
       39
        
       (** Extract a boolean field with a default value *)

     

       40
       40
        
       val get_bool_default : (string * json) list -> string -> bool -> bool

     
···

       43
       43
        
       val get_bool_opt : (string * json) list -> string -> bool option

     

       44
       44
        
       

     

       45
       45
        
       (** Extract a JSON object field *)

     

       46
       46
       -
       val get_object : (string * json) list -> string -> ((string * json) list, Zerror.t) result

     

       46
       46
       +
       val get_object : (string * json) list -> string -> ((string * json) list, Zulip_types.zerror) result

     

       47
       47
        
       

     

       48
       48
        
       (** Extract an optional JSON object field *)

     

       49
       49
        
       val get_object_opt : (string * json) list -> string -> (string * json) list option

     

       50
       50
        
       

     

       51
       51
        
       (** Extract a JSON array field *)

     

       52
       52
       -
       val get_array : (string * json) list -> string -> (json list, Zerror.t) result

     

       52
       52
       +
       val get_array : (string * json) list -> string -> (json list, Zulip_types.zerror) result

     

       53
       53
        
       

     

       54
       54
        
       (** Extract an optional JSON array field *)

     

       55
       55
        
       val get_array_opt : (string * json) list -> string -> json list option

     
···

       74
       74
        
       (** {1 Object parsing utilities} *)

     

       75
       75
        
       

     

       76
       76
        
       (** Parse a JSON value as an object, applying a function to its fields *)

     

       77
       77
       -
       val with_object : string -> ((string * json) list -> ('a, Zerror.t) result) -> json -> ('a, Zerror.t) result

     

       77
       77
       +
       val with_object : string -> ((string * json) list -> ('a, Zulip_types.zerror) result) -> json -> ('a, Zulip_types.zerror) result

     

       78
       78
        
       

     

       79
       79
        
       (** Parse a JSON value as an array, applying a function to each element *)

     

       80
       80
       -
       val with_array : string -> (json -> ('a, Zerror.t) result) -> json -> ('a list, Zerror.t) result

     

       80
       80
       +
       val with_array : string -> (json -> ('a, Zulip_types.zerror) result) -> json -> ('a list, Zulip_types.zerror) result

     

       81
       81
        
       

     

       82
       82
        
       (** {1 Construction utilities} *)

     

       83
       83
        
       

     
···

       96
       96
        
       (** {1 Error handling} *)

     

       97
       97
        
       

     

       98
       98
        
       (** Create a JSON parsing error *)

     

       99
       99
       -
       val json_error : string -> Zerror.t

     

       99
       99
       +
       val json_error : string -> Zulip_types.zerror

     

       100
       100
        
       

     

       101
       101
        
       (** Create a field missing error *)

     

       102
       102
       -
       val field_missing_error : string -> Zerror.t

     

       102
       102
       +
       val field_missing_error : string -> Zulip_types.zerror

     

       103
       103
        
       

     

       104
       104
        
       (** Create a type mismatch error *)

     

       105
       105
       -
       val type_mismatch_error : string -> string -> Zerror.t

     

       105
       105
       +
       val type_mismatch_error : string -> string -> Zulip_types.zerror

     

       106
       106
        
       

     

       107
       107
        
       (** Wrap a parsing function with exception handling *)

     

       108
       108
       -
       val parse_with_error : string -> (unit -> ('a, Zerror.t) result) -> ('a, Zerror.t) result

     

       108
       108
       +
       val parse_with_error : string -> (unit -> ('a, Zulip_types.zerror) result) -> ('a, Zulip_types.zerror) result

     

       109
       109
        
       

     

       110
       110
        
       

     

       111
       111
        
       (** {1 Debugging utilities} *)

+13 -14

stack/zulip/lib/zulip/lib/jsonu_syntax.ml

···

       1
       1
        
       (** Syntax module for monadic and applicative JSON parsing *)

     

       2
       2
        
       

     

       3
       3
       -
       open Zerror

     

       4
       4
       -
       

     

       5
       5
       -
       type 'a parser = json -> ('a, Zerror.t) result

     

       3
       3
       +
       type json = Zulip_types.json

     

       4
       4
       +
       type 'a parser = json -> ('a, Zulip_types.zerror) result

     

       6
       5
        
       

     

       7
       6
        
       (** Monadic bind operator for sequential parsing with error handling *)

     

       8
       7
        
       let ( let* ) = Result.bind

     
···

       49
       48
        
       (** Convert option to result with error message *)

     

       50
       49
        
       let required name = function

     

       51
       50
        
         | Some v -> Ok v

     

       52
       52
       -
         | None -> Error (Zerror.create ~code:(Other "missing_field") ~msg:(Printf.sprintf "Required field '%s' not found" name) ())

     

       51
       51
       +
         | None -> Error (Zulip_types.create_error ~code:(Other "missing_field") ~msg:(Printf.sprintf "Required field '%s' not found" name) ())

     

       53
       52
        
       

     

       54
       53
        
       (** Convert option to result with default *)

     

       55
       54
        
       let default v = function

     
···

       60
       59
        
       let pure x = Ok x

     

       61
       60
        
       

     

       62
       61
        
       (** Fail with an error message *)

     

       63
       63
       -
       let fail msg = Error (Zerror.create ~code:(Other "parse_error") ~msg ())

     

       62
       62
       +
       let fail msg = Error (Zulip_types.create_error ~code:(Other "parse_error") ~msg ())

     

       64
       63
        
       

     

       65
       64
        
       (** Map over a list with error handling *)

     

       66
       65
        
       let traverse f lst =

     
···

       107
       106
        
       (** Common parsers *)

     

       108
       107
        
       let string = function

     

       109
       108
        
         | `String s -> Ok s

     

       110
       110
       -
         | _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected string" ())

     

       109
       109
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected string" ())

     

       111
       110
        
       

     

       112
       111
        
       let int = function

     

       113
       112
        
         | `Float f -> Ok (int_of_float f)

     

       114
       113
        
         | `String s ->

     

       115
       114
        
             (try Ok (int_of_string s)

     

       116
       116
       -
              with _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected integer" ()))

     

       117
       117
       -
         | _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected integer" ())

     

       115
       115
       +
              with _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected integer" ()))

     

       116
       116
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected integer" ())

     

       118
       117
        
       

     

       119
       118
        
       let float = function

     

       120
       119
        
         | `Float f -> Ok f

     

       121
       120
        
         | `String s ->

     

       122
       121
        
             (try Ok (float_of_string s)

     

       123
       123
       -
              with _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected float" ()))

     

       124
       124
       -
         | _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected float" ())

     

       122
       122
       +
              with _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected float" ()))

     

       123
       123
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected float" ())

     

       125
       124
        
       

     

       126
       125
        
       let bool = function

     

       127
       126
        
         | `Bool b -> Ok b

     

       128
       128
       -
         | _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected boolean" ())

     

       127
       127
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected boolean" ())

     

       129
       128
        
       

     

       130
       129
        
       let array parser = function

     

       131
       130
        
         | `A items -> traverse parser items

     

       132
       132
       -
         | _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected array" ())

     

       131
       131
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected array" ())

     

       133
       132
        
       

     

       134
       133
        
       let object_ = function

     

       135
       134
        
         | `O fields -> Ok fields

     

       136
       136
       -
         | _ -> Error (Zerror.create ~code:(Other "type_error") ~msg:"Expected object" ())

     

       135
       135
       +
         | _ -> Error (Zulip_types.create_error ~code:(Other "type_error") ~msg:"Expected object" ())

     

       137
       136
        
       

     

       138
       137
        
       (** Run a parser on JSON *)

     

       139
       138
        
       let parse parser json = parser json

     
···

       142
       141
        
       let with_context ctx parser json =

     

       143
       142
        
         match parser json with

     

       144
       143
        
         | Ok v -> Ok v

     

       145
       145
       -
         | Error e -> Error (Zerror.create ~code:(Zerror.code e) ~msg:(Printf.sprintf "%s: %s" ctx (Zerror.message e)) ())
     

       144
       144
       +
         | Error e -> Error (Zulip_types.create_error ~code:(Zulip_types.error_code e) ~msg:(Printf.sprintf "%s: %s" ctx (Zulip_types.error_message e)) ())

+11 -12

stack/zulip/lib/zulip/lib/jsonu_syntax.mli

···

       13
       13
        
           ]}

     

       14
       14
        
       *)

     

       15
       15
        
       

     

       16
       16
       -
       open Zerror

     

       17
       17
       -
       

     

       18
       18
       -
       type 'a parser = json -> ('a, Zerror.t) result

     

       16
       16
       +
       type json = Zulip_types.json

     

       17
       17
       +
       type 'a parser = json -> ('a, Zulip_types.zerror) result

     

       19
       18
        
       

     

       20
       19
        
       (** {1 Binding Operators} *)

     

       21
       20
        
       

     
···

       42
       41
        
       (** {1 Field Extraction} *)

     

       43
       42
        
       

     

       44
       43
        
       (** Parse a required field with a custom parser *)

     

       45
       45
       -
       val field : (string * json) list -> string -> 'a parser -> ('a, Zerror.t) result

     

       44
       44
       +
       val field : (string * json) list -> string -> 'a parser -> ('a, Zulip_types.zerror) result

     

       46
       45
        
       

     

       47
       46
        
       (** Parse an optional field with a custom parser *)

     

       48
       48
       -
       val field_opt : (string * json) list -> string -> 'a parser -> ('a option, Zerror.t) result

     

       47
       47
       +
       val field_opt : (string * json) list -> string -> 'a parser -> ('a option, Zulip_types.zerror) result

     

       49
       48
        
       

     

       50
       49
        
       (** Parse a field with a default value if missing or fails *)

     

       51
       51
       -
       val field_or : (string * json) list -> string -> 'a parser -> 'a -> ('a, Zerror.t) result

     

       50
       50
       +
       val field_or : (string * json) list -> string -> 'a parser -> 'a -> ('a, Zulip_types.zerror) result

     

       52
       51
        
       

     

       53
       52
        
       (** {1 Basic Parsers} *)

     

       54
       53
        
       

     
···

       68
       67
        
       val array : 'a parser -> 'a list parser

     

       69
       68
        
       

     

       70
       69
        
       (** Parse a JSON object to get its fields *)

     

       71
       71
       -
       val object_ : json -> ((string * json) list, Zerror.t) result

     

       70
       70
       +
       val object_ : json -> ((string * json) list, Zulip_types.zerror) result

     

       72
       71
        
       

     

       73
       72
        
       (** {1 Utility Functions} *)

     

       74
       73
        
       

     

       75
       74
        
       (** Convert option to result with error message *)

     

       76
       76
       -
       val required : string -> 'a option -> ('a, Zerror.t) result

     

       75
       75
       +
       val required : string -> 'a option -> ('a, Zulip_types.zerror) result

     

       77
       76
        
       

     

       78
       77
        
       (** Get value from option with default *)

     

       79
       78
        
       val default : 'a -> 'a option -> 'a

     
···

       82
       81
        
       val pure : 'a -> ('a, 'e) result

     

       83
       82
        
       

     

       84
       83
        
       (** Fail with an error message *)

     

       85
       85
       -
       val fail : string -> ('a, Zerror.t) result

     

       84
       84
       +
       val fail : string -> ('a, Zulip_types.zerror) result

     

       86
       85
        
       

     

       87
       86
        
       (** Map over a list with error handling *)

     

       88
       88
       -
       val traverse : ('a -> ('b, Zerror.t) result) -> 'a list -> ('b list, Zerror.t) result

     

       87
       87
       +
       val traverse : ('a -> ('b, Zulip_types.zerror) result) -> 'a list -> ('b list, Zulip_types.zerror) result

     

       89
       88
        
       

     

       90
       89
        
       (** Filter and map over a list, dropping errors *)

     

       91
       91
       -
       val filter_map : ('a -> ('b, Zerror.t) result) -> 'a list -> 'b list

     

       90
       90
       +
       val filter_map : ('a -> ('b, Zulip_types.zerror) result) -> 'a list -> 'b list

     

       92
       91
        
       

     

       93
       92
        
       (** Run a parser on JSON *)

     

       94
       94
       -
       val parse : 'a parser -> json -> ('a, Zerror.t) result

     

       93
       93
       +
       val parse : 'a parser -> json -> ('a, Zulip_types.zerror) result

     

       95
       94
        
       

     

       96
       95
        
       (** Run a parser with error context *)

     

       97
       96
        
       val with_context : string -> 'a parser -> 'a parser

+1 -1

stack/zulip/lib/zulip/lib/message.mli

···

       17
       17
        
       val queue_id : t -> string option

     

       18
       18
        
       val local_id : t -> string option

     

       19
       19
        
       val read_by_sender : t -> bool

     

       20
       20
       -
       val to_json : t -> Zerror.json

     

       20
       20
       +
       val to_json : t -> Zulip_types.json

     

       21
       21
        
       val pp : Format.formatter -> t -> unit

+1 -1

stack/zulip/lib/zulip/lib/message_response.mli

···

       2
       2
        
       

     

       3
       3
        
       val id : t -> int

     

       4
       4
        
       val automatic_new_visibility_policy : t -> string option

     

       5
       5
       -
       val of_json : Zerror.json -> (t, Zerror.t) result

     

       5
       5
       +
       val of_json : Zulip_types.json -> (t, Zulip_types.zerror) result

     

       6
       6
        
       val pp : Format.formatter -> t -> unit

+5 -5

stack/zulip/lib/zulip/lib/messages.mli

···

       1
       1
       -
       val send : Client.t -> Message.t -> (Message_response.t, Zerror.t) result

     

       2
       2
       -
       val edit : Client.t -> message_id:int -> ?content:string -> ?topic:string -> unit -> (unit, Zerror.t) result

     

       3
       3
       -
       val delete : Client.t -> message_id:int -> (unit, Zerror.t) result

     

       4
       4
       -
       val get : Client.t -> message_id:int -> (Zerror.json, Zerror.t) result

     

       1
       1
       +
       val send : Client.t -> Message.t -> (Message_response.t, Zulip_types.zerror) result

     

       2
       2
       +
       val edit : Client.t -> message_id:int -> ?content:string -> ?topic:string -> unit -> (unit, Zulip_types.zerror) result

     

       3
       3
       +
       val delete : Client.t -> message_id:int -> (unit, Zulip_types.zerror) result

     

       4
       4
       +
       val get : Client.t -> message_id:int -> (Zulip_types.json, Zulip_types.zerror) result

     

       5
       5
        
       val get_messages :

     

       6
       6
        
         Client.t ->

     

       7
       7
        
         ?anchor:string ->

     
···

       9
       9
        
         ?num_after:int ->

     

       10
       10
        
         ?narrow:string list ->

     

       11
       11
        
         unit ->

     

       12
       12
       -
         (Zerror.json, Zerror.t) result
     

       12
       12
       +
         (Zulip_types.json, Zulip_types.zerror) result

+2 -2

stack/zulip/lib/zulip/lib/user.mli

···

       13
       13
        
       val is_active : t -> bool

     

       14
       14
        
       val is_admin : t -> bool

     

       15
       15
        
       val is_bot : t -> bool

     

       16
       16
       -
       val to_json : t -> Zerror.json

     

       17
       17
       -
       val of_json : Zerror.json -> (t, Zerror.t) result

     

       16
       16
       +
       val to_json : t -> Zulip_types.json

     

       17
       17
       +
       val of_json : Zulip_types.json -> (t, Zulip_types.zerror) result

     

       18
       18
        
       val pp : Format.formatter -> t -> unit

+2 -2

stack/zulip/lib/zulip/lib/users.ml

···

       11
       11
        
                         | Error _ -> acc

     

       12
       12
        
                       ) [] user_list in

     

       13
       13
        
                       Ok (List.rev users)

     

       14
       14
       -
                   | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Invalid users response format" ()))

     

       15
       15
       -
              | _ -> Error (Zerror.create ~code:(Other "api_error") ~msg:"Users response must be an object" ()))

     

       14
       14
       +
                   | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Invalid users response format" ()))

     

       15
       15
       +
              | _ -> Error (Zulip_types.create_error ~code:(Other "api_error") ~msg:"Users response must be an object" ()))

     

       16
       16
        
         | Error err -> Error err

     

       17
       17
        
       

     

       18
       18
        
       let get client ~email =

+4 -4

stack/zulip/lib/zulip/lib/users.mli

···

       1
       1
       -
       val list : Client.t -> (User.t list, Zerror.t) result

     

       2
       2
       -
       val get : Client.t -> email:string -> (User.t, Zerror.t) result

     

       3
       3
       -
       val create_user : Client.t -> email:string -> full_name:string -> (unit, Zerror.t) result

     

       4
       4
       -
       val deactivate : Client.t -> email:string -> (unit, Zerror.t) result
     

       1
       1
       +
       val list : Client.t -> (User.t list, Zulip_types.zerror) result

     

       2
       2
       +
       val get : Client.t -> email:string -> (User.t, Zulip_types.zerror) result

     

       3
       3
       +
       val create_user : Client.t -> email:string -> full_name:string -> (unit, Zulip_types.zerror) result

     

       4
       4
       +
       val deactivate : Client.t -> email:string -> (unit, Zulip_types.zerror) result

+48

stack/zulip/lib/zulip/lib/zulip.ml

···

       1
       1
       +
       (** Main module for Zulip OCaml API bindings *)

     

       2
       2
       +
       

     

       3
       3
       +
       (* Re-export core types from Zulip_types *)

     

       4
       4
       +
       type json = Zulip_types.json

     

       5
       5
       +
       type error_code = Zulip_types.error_code =

     

       6
       6
       +
         | Invalid_api_key

     

       7
       7
       +
         | Request_variable_missing

     

       8
       8
       +
         | Bad_request

     

       9
       9
       +
         | User_deactivated

     

       10
       10
       +
         | Realm_deactivated

     

       11
       11
       +
         | Rate_limit_hit

     

       12
       12
       +
         | Other of string

     

       13
       13
       +
       

     

       14
       14
       +
       type zerror = Zulip_types.zerror = {

     

       15
       15
       +
         code : error_code;

     

       16
       16
       +
         message : string;

     

       17
       17
       +
         extra : (string * json) list;

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       let error_code_to_string = Zulip_types.error_code_to_string

     

       21
       21
       +
       let error_code_of_string = Zulip_types.error_code_of_string

     

       22
       22
       +
       let create_error = Zulip_types.create_error

     

       23
       23
       +
       let error_code = Zulip_types.error_code

     

       24
       24
       +
       let error_message = Zulip_types.error_message

     

       25
       25
       +
       let error_extra = Zulip_types.error_extra

     

       26
       26
       +
       let pp_error = Zulip_types.pp_error

     

       27
       27
       +
       let error_of_json = Zulip_types.error_of_json

     

       28
       28
       +
       

     

       29
       29
       +
       

     

       30
       30
       +
       (** Re-export all submodules *)

     

       31
       31
       +
       module Auth = Auth

     

       32
       32
       +
       module Client = Client

     

       33
       33
       +
       module Message = Message

     

       34
       34
       +
       module Message_type = Message_type

     

       35
       35
       +
       module Message_response = Message_response

     

       36
       36
       +
       module Messages = Messages

     

       37
       37
       +
       module Channel = Channel

     

       38
       38
       +
       module Channels = Channels

     

       39
       39
       +
       module User = User

     

       40
       40
       +
       module Users = Users

     

       41
       41
       +
       module Event = Event

     

       42
       42
       +
       module Event_type = Event_type

     

       43
       43
       +
       module Event_queue = Event_queue

     

       44
       44
       +
       

     

       45
       45
       +
       (** JSON utilities with short alias *)

     

       46
       46
       +
       module J = Jsonu

     

       47
       47
       +
       module Jsonu_syntax = Jsonu_syntax

     

       48
       48
       +
       module Jsonu = Jsonu

+78

stack/zulip/lib/zulip/lib/zulip.mli

···

       1
       1
       +
       (** Zulip API client library for OCaml

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides a comprehensive interface to the Zulip REST API,

     

       4
       4
       +
           with support for messages, channels, users, and real-time events. *)

     

       5
       5
       +
       

     

       6
       6
       +
       (** {1 Core Types} *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** JSON type used throughout the API *)

     

       9
       9
       +
       type json = Zulip_types.json

     

       10
       10
       +
       

     

       11
       11
       +
       (** {2 Error Handling} *)

     

       12
       12
       +
       

     

       13
       13
       +
       (** Error codes returned by Zulip API *)

     

       14
       14
       +
       type error_code = Zulip_types.error_code =

     

       15
       15
       +
         | Invalid_api_key

     

       16
       16
       +
         | Request_variable_missing

     

       17
       17
       +
         | Bad_request

     

       18
       18
       +
         | User_deactivated

     

       19
       19
       +
         | Realm_deactivated

     

       20
       20
       +
         | Rate_limit_hit

     

       21
       21
       +
         | Other of string

     

       22
       22
       +
       

     

       23
       23
       +
       (** Zulip-specific error type *)

     

       24
       24
       +
       type zerror = Zulip_types.zerror = {

     

       25
       25
       +
         code : error_code;

     

       26
       26
       +
         message : string;

     

       27
       27
       +
         extra : (string * json) list;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       (** {3 Error Functions} *)

     

       31
       31
       +
       

     

       32
       32
       +
       val error_code_to_string : error_code -> string

     

       33
       33
       +
       val error_code_of_string : string -> error_code

     

       34
       34
       +
       val create_error : code:error_code -> msg:string -> ?extra:(string * json) list -> unit -> zerror

     

       35
       35
       +
       val error_code : zerror -> error_code

     

       36
       36
       +
       val error_message : zerror -> string

     

       37
       37
       +
       val error_extra : zerror -> (string * json) list

     

       38
       38
       +
       val pp_error : Format.formatter -> zerror -> unit

     

       39
       39
       +
       val error_of_json : json -> zerror option

     

       40
       40
       +
       

     

       41
       41
       +
       (** {1 Submodules} *)

     

       42
       42
       +
       

     

       43
       43
       +
       (** Authentication management *)

     

       44
       44
       +
       module Auth = Auth

     

       45
       45
       +
       

     

       46
       46
       +
       (** Client for making API requests *)

     

       47
       47
       +
       module Client = Client

     

       48
       48
       +
       

     

       49
       49
       +
       (** Message types and operations *)

     

       50
       50
       +
       module Message = Message

     

       51
       51
       +
       module Message_type = Message_type

     

       52
       52
       +
       module Message_response = Message_response

     

       53
       53
       +
       module Messages = Messages

     

       54
       54
       +
       

     

       55
       55
       +
       (** Channel (stream) operations *)

     

       56
       56
       +
       module Channel = Channel

     

       57
       57
       +
       module Channels = Channels

     

       58
       58
       +
       

     

       59
       59
       +
       (** User management *)

     

       60
       60
       +
       module User = User

     

       61
       61
       +
       module Users = Users

     

       62
       62
       +
       

     

       63
       63
       +
       (** Event handling *)

     

       64
       64
       +
       module Event = Event

     

       65
       65
       +
       module Event_type = Event_type

     

       66
       66
       +
       module Event_queue = Event_queue

     

       67
       67
       +
       

     

       68
       68
       +
       (** {1 JSON Utilities} *)

     

       69
       69
       +
       

     

       70
       70
       +
       (** JSON utility functions (abbreviated as J for convenience) *)

     

       71
       71
       +
       module J = Jsonu

     

       72
       72
       +
       

     

       73
       73
       +
       (** JSON parsing syntax extensions *)

     

       74
       74
       +
       module Jsonu_syntax = Jsonu_syntax

     

       75
       75
       +
       

     

       76
       76
       +
       (** Full JSON utilities module *)

     

       77
       77
       +
       module Jsonu = Jsonu

     

       78
       78
       +

+4 -4

stack/zulip/lib/zulip_bot/lib/bot_config.ml

···

       54
       54
        
           Ok config

     

       55
       55
        
         with

     

       56
       56
        
         | Sys_error msg ->

     

       57
       57
       -
             Error (Zulip.Zerror.create ~code:(Other "file_error") ~msg:("Cannot read config file: " ^ msg) ())

     

       57
       57
       +
             Error (Zulip.create_error ~code:(Other "file_error") ~msg:("Cannot read config file: " ^ msg) ())

     

       58
       58
        
         | exn ->

     

       59
       59
       -
             Error (Zulip.Zerror.create ~code:(Other "parse_error") ~msg:("Error parsing config: " ^ Printexc.to_string exn) ())

     

       59
       59
       +
             Error (Zulip.create_error ~code:(Other "parse_error") ~msg:("Error parsing config: " ^ Printexc.to_string exn) ())

     

       60
       60
        
       

     

       61
       61
        
       let from_env ~prefix =

     

       62
       62
        
         try

     
···

       76
       76
        
           Ok config

     

       77
       77
        
         with

     

       78
       78
        
         | exn ->

     

       79
       79
       -
             Error (Zulip.Zerror.create ~code:(Other "env_error") ~msg:("Error reading environment: " ^ Printexc.to_string exn) ())

     

       79
       79
       +
             Error (Zulip.create_error ~code:(Other "env_error") ~msg:("Error reading environment: " ^ Printexc.to_string exn) ())

     

       80
       80
        
       

     

       81
       81
        
       let get t ~key =

     

       82
       82
        
         Hashtbl.find_opt t key

     
···

       84
       84
        
       let get_required t ~key =

     

       85
       85
        
         match Hashtbl.find_opt t key with

     

       86
       86
        
         | Some value -> Ok value

     

       87
       87
       -
         | None -> Error (Zulip.Zerror.create ~code:(Other "config_missing") ~msg:("Required config key missing: " ^ key) ())

     

       87
       87
       +
         | None -> Error (Zulip.create_error ~code:(Other "config_missing") ~msg:("Required config key missing: " ^ key) ())

     

       88
       88
        
       

     

       89
       89
        
       let has_key t ~key =

     

       90
       90
        
         Hashtbl.mem t key

+3 -3

stack/zulip/lib/zulip_bot/lib/bot_config.mli

···

       6
       6
        
       val create : (string * string) list -> t

     

       7
       7
        
       

     

       8
       8
        
       (** Load configuration from file *)

     

       9
       9
       -
       val from_file : string -> (t, Zulip.Zerror.t) result

     

       9
       9
       +
       val from_file : string -> (t, Zulip.zerror) result

     

       10
       10
        
       

     

       11
       11
        
       (** Load configuration from environment variables with prefix *)

     

       12
       12
       -
       val from_env : prefix:string -> (t, Zulip.Zerror.t) result

     

       12
       12
       +
       val from_env : prefix:string -> (t, Zulip.zerror) result

     

       13
       13
        
       

     

       14
       14
        
       (** Get a configuration value *)

     

       15
       15
        
       val get : t -> key:string -> string option

     

       16
       16
        
       

     

       17
       17
        
       (** Get a required configuration value, failing if not present *)

     

       18
       18
       -
       val get_required : t -> key:string -> (string, Zulip.Zerror.t) result

     

       18
       18
       +
       val get_required : t -> key:string -> (string, Zulip.zerror) result

     

       19
       19
        
       

     

       20
       20
        
       (** Check if a key exists in configuration *)

     

       21
       21
        
       val has_key : t -> key:string -> bool

+2 -2

stack/zulip/lib/zulip_bot/lib/bot_handler.ml

···

       27
       27
        
       

     

       28
       28
        
       (** Module signature for bot implementations *)

     

       29
       29
        
       module type Bot_handler = sig

     

       30
       30
       -
         val initialize : Bot_config.t -> (unit, Zulip.Zerror.t) result

     

       30
       30
       +
         val initialize : Bot_config.t -> (unit, Zulip.zerror) result

     

       31
       31
        
         val usage : unit -> string

     

       32
       32
        
         val description : unit -> string

     

       33
       33
        
         val handle_message :

     
···

       36
       36
        
           identity:Identity.t ->

     

       37
       37
        
           message:Message.t ->

     

       38
       38
        
           env:_ ->

     

       39
       39
       -
           (Response.t, Zulip.Zerror.t) result

     

       39
       39
       +
           (Response.t, Zulip.zerror) result

     

       40
       40
        
       end

     

       41
       41
        
       

     

       42
       42
        
       module type S = Bot_handler

+3 -3

stack/zulip/lib/zulip_bot/lib/bot_handler.mli

···

       28
       28
        
       (** Module signature for bot implementations *)

     

       29
       29
        
       module type Bot_handler = sig

     

       30
       30
        
         (** Initialize the bot (called once on startup) *)

     

       31
       31
       -
         val initialize : Bot_config.t -> (unit, Zulip.Zerror.t) result

     

       31
       31
       +
         val initialize : Bot_config.t -> (unit, Zulip.zerror) result

     

       32
       32
        
       

     

       33
       33
        
         (** Provide usage/help text *)

     

       34
       34
        
         val usage : unit -> string

     
···

       43
       43
        
           identity:Identity.t ->

     

       44
       44
        
           message:Message.t ->

     

       45
       45
        
           env:_ ->

     

       46
       46
       -
           (Response.t, Zulip.Zerror.t) result

     

       46
       46
       +
           (Response.t, Zulip.zerror) result

     

       47
       47
        
       end

     

       48
       48
        
       

     

       49
       49
        
       (** Shorter alias for Bot_handler *)

     
···

       61
       61
        
         t

     

       62
       62
        
       

     

       63
       63
        
       (** Process an incoming message with EIO environment *)

     

       64
       64
       -
       val handle_message_with_env : t -> _ -> Message.t -> (Response.t, Zulip.Zerror.t) result

     

       64
       64
       +
       val handle_message_with_env : t -> _ -> Message.t -> (Response.t, Zulip.zerror) result

     

       65
       65
        
       

     

       66
       66
        
       

     

       67
       67
        
       (** Get bot identity *)

+8 -8

stack/zulip/lib/zulip_bot/lib/bot_runner.ml

···

       117
       117
        
                             Log.info (fun m -> m "Reply sent successfully (id: %d)"

     

       118
       118
        
                               (Zulip.Message_response.id resp))

     

       119
       119
        
                         | Error e ->

     

       120
       120
       -
                             Log.err (fun m -> m "Error sending reply: %s" (Zulip.Zerror.message e)))

     

       120
       120
       +
                             Log.err (fun m -> m "Error sending reply: %s" (Zulip.error_message e)))

     

       121
       121
        
       

     

       122
       122
        
                    | Ok (Bot_handler.Response.None) ->

     

       123
       123
        
                        Log.info (fun m -> m "Bot handler returned no response")

     

       124
       124
        
                    | Ok _ ->

     

       125
       125
        
                        Log.info (fun m -> m "Bot handler returned unhandled response type")

     

       126
       126
        
                    | Error e ->

     

       127
       127
       -
                        Log.err (fun m -> m "Error handling message: %s" (Zulip.Zerror.message e))

     

       127
       127
       +
                        Log.err (fun m -> m "Error handling message: %s" (Zulip.error_message e))

     

       128
       128
        
                  ) else (

     

       129
       129
        
                    Log.info (fun m -> m "Not processing message (not mentioned and not private)")

     

       130
       130
        
                  )

     
···

       142
       142
        
         match Zulip.Event_queue.register t.client

     

       143
       143
        
                 ~event_types:[Zulip.Event_type.Message] () with

     

       144
       144
        
         | Error e ->

     

       145
       145
       -
             Log.err (fun m -> m "Failed to register event queue: %s" (Zulip.Zerror.message e));

     

       145
       145
       +
             Log.err (fun m -> m "Failed to register event queue: %s" (Zulip.error_message e));

     

       146
       146
        
             t.running <- false

     

       147
       147
        
         | Ok queue ->

     

       148
       148
        
             Log.info (fun m -> m "Event queue registered: %s" (Zulip.Event_queue.id queue));

     
···

       154
       154
        
                 (* Clean up event queue *)

     

       155
       155
        
                 (match Zulip.Event_queue.delete queue t.client with

     

       156
       156
        
                  | Ok () -> Log.info (fun m -> m "Event queue deleted")

     

       157
       157
       -
                  | Error e -> Log.err (fun m -> m "Error deleting queue: %s" (Zulip.Zerror.message e)))

     

       157
       157
       +
                  | Error e -> Log.err (fun m -> m "Error deleting queue: %s" (Zulip.error_message e)))

     

       158
       158
        
               ) else

     

       159
       159
        
                 (* Get events from Zulip *)

     

       160
       160
        
                 match Zulip.Event_queue.get_events queue t.client ~last_event_id () with

     
···

       184
       184
        
                 | Error e ->

     

       185
       185
        
                     (* Handle errors with exponential backoff *)

     

       186
       186
        
                     Log.warn (fun m -> m "Error getting events: %s (retrying in 2s)"

     

       187
       187
       -
                       (Zulip.Zerror.message e));

     

       187
       187
       +
                       (Zulip.error_message e));

     

       188
       188
        
       

     

       189
       189
        
                     (* Sleep using EIO clock *)

     

       190
       190
        
                     Eio.Time.sleep clock 2.0;

     

       191
       191
        
       

     

       192
       192
        
                     (* Check if error is recoverable *)

     

       193
       193
        
                     let is_recoverable =

     

       194
       194
       -
                       match Zulip.Zerror.code e with

     

       195
       195
       -
                       | Zulip.Zerror.Other "api_error" -> true

     

       194
       194
       +
                       match Zulip.error_code e with

     

       195
       195
       +
                       | Zulip.Other "api_error" -> true

     

       196
       196
        
                       | _ -> true (* For now, treat all errors as recoverable *)

     

       197
       197
        
                     in

     

       198
       198
        
       

     
···

       218
       218
        
         (* Process webhook data and route to handler *)

     

       219
       219
        
         (* Parse the webhook data into Message.t first *)

     

       220
       220
        
         match Message.of_json webhook_data with

     

       221
       221
       -
         | Error err -> Error (Zulip.Zerror.create ~code:(Zulip.Zerror.Other "parse_error") ~msg:("Failed to parse webhook message: " ^ err) ())

     

       221
       221
       +
         | Error err -> Error (Zulip.create_error ~code:(Zulip.Other "parse_error") ~msg:("Failed to parse webhook message: " ^ err) ())

     

       222
       222
        
         | Ok message ->

     

       223
       223
        
             match Bot_handler.handle_message_with_env t.handler t.env message with

     

       224
       224
        
             | Ok response -> Ok (Some response)

+2 -2

stack/zulip/lib/zulip_bot/lib/bot_runner.mli

···

       18
       18
        
       (** Process a single webhook event *)

     

       19
       19
        
       val handle_webhook :

     

       20
       20
        
         'env t ->

     

       21
       21
       -
         webhook_data:Zulip.Zerror.json ->

     

       22
       22
       -
         (Bot_handler.Response.t option, Zulip.Zerror.t) result

     

       21
       21
       +
         webhook_data:Zulip.json ->

     

       22
       22
       +
         (Bot_handler.Response.t option, Zulip.zerror) result

     

       23
       23
        
       

     

       24
       24
        
       (** Gracefully shutdown the bot *)

     

       25
       25
        
       val shutdown : 'env t -> unit

+4 -4

stack/zulip/lib/zulip_bot/lib/bot_storage.ml

···

       30
       30
        
                  ) storage_fields

     

       31
       31
        
              | None -> ())

     

       32
       32
        
         | Error e ->

     

       33
       33
       -
             Log.warn (fun m -> m "Failed to load existing storage: %s" (Zulip.Zerror.message e)));

     

       33
       33
       +
             Log.warn (fun m -> m "Failed to load existing storage: %s" (Zulip.error_message e)));

     

       34
       34
        
       

     

       35
       35
        
         {

     

       36
       36
        
           client;

     
···

       106
       106
        
                           None)

     

       107
       107
        
                  | None -> None)

     

       108
       108
        
             | Error e ->

     

       109
       109
       -
                 Log.warn (fun m -> m "Error fetching key %s: %s" key (Zulip.Zerror.message e));

     

       109
       109
       +
                 Log.warn (fun m -> m "Error fetching key %s: %s" key (Zulip.error_message e));

     

       110
       110
        
                 None

     

       111
       111
        
       

     

       112
       112
        
       let put t ~key ~value =

     
···

       133
       133
        
             t.dirty_keys <- List.filter ((<>) key) t.dirty_keys;

     

       134
       134
        
             Ok ()

     

       135
       135
        
         | Error e ->

     

       136
       136
       -
             Log.err (fun m -> m "Failed to store key %s: %s" key (Zulip.Zerror.message e));

     

       136
       136
       +
             Log.err (fun m -> m "Failed to store key %s: %s" key (Zulip.error_message e));

     

       137
       137
        
             Error e

     

       138
       138
        
       

     

       139
       139
        
       let contains t ~key =

     
···

       205
       205
        
                 t.dirty_keys <- [];

     

       206
       206
        
                 Ok ()

     

       207
       207
        
             | Error e ->

     

       208
       208
       -
                 Log.err (fun m -> m "Failed to flush storage: %s" (Zulip.Zerror.message e));

     

       208
       208
       +
                 Log.err (fun m -> m "Failed to flush storage: %s" (Zulip.error_message e));

     

       209
       209
        
                 Error e

     

       210
       210
        
           end

+4 -4

stack/zulip/lib/zulip_bot/lib/bot_storage.mli

···

       9
       9
        
       val get : t -> key:string -> string option

     

       10
       10
        
       

     

       11
       11
        
       (** Store a value in storage *)

     

       12
       12
       -
       val put : t -> key:string -> value:string -> (unit, Zulip.Zerror.t) result

     

       12
       12
       +
       val put : t -> key:string -> value:string -> (unit, Zulip.zerror) result

     

       13
       13
        
       

     

       14
       14
        
       (** Check if a key exists in storage *)

     

       15
       15
        
       val contains : t -> key:string -> bool

     

       16
       16
        
       

     

       17
       17
        
       (** Remove a key from storage *)

     

       18
       18
       -
       val remove : t -> key:string -> (unit, Zulip.Zerror.t) result

     

       18
       18
       +
       val remove : t -> key:string -> (unit, Zulip.zerror) result

     

       19
       19
        
       

     

       20
       20
        
       (** List all keys in storage *)

     

       21
       21
       -
       val keys : t -> (string list, Zulip.Zerror.t) result

     

       21
       21
       +
       val keys : t -> (string list, Zulip.zerror) result

     

       22
       22
        
       

     

       23
       23
        
       (** Flush all dirty keys to the API *)

     

       24
       24
       -
       val flush : t -> (unit, Zulip.Zerror.t) result
     

       24
       24
       +
       val flush : t -> (unit, Zulip.zerror) result

+8 -8

stack/zulip/lib/zulip_bot/lib/message.ml

···

       17
       17
        
         let full_name t = t.full_name

     

       18
       18
        
         let short_name t = t.short_name

     

       19
       19
        
       

     

       20
       20
       -
         let of_json (json : Zulip.Zerror.json) : (t, Zulip.Zerror.t) result =

     

       20
       20
       +
         let of_json (json : Zulip.json) : (t, Zulip.zerror) result =

     

       21
       21
        
           let open Zulip.Jsonu_syntax in

     

       22
       22
        
           (Zulip.Jsonu.with_object "user" @@ fun fields ->

     

       23
       23
        
           let* user_id = (field fields "user_id" int) <|> (field fields "id" int) in

     
···

       41
       41
        
         let reaction_type t = t.reaction_type

     

       42
       42
        
         let user_id t = t.user_id

     

       43
       43
        
       

     

       44
       44
       -
         let of_json (json : Zulip.Zerror.json) : (t, Zulip.Zerror.t) result =

     

       44
       44
       +
         let of_json (json : Zulip.json) : (t, Zulip.zerror) result =

     

       45
       45
        
           let open Zulip.Jsonu_syntax in

     

       46
       46
        
           (Zulip.Jsonu.with_object "reaction" @@ fun fields ->

     

       47
       47
        
           let* emoji_name = field fields "emoji_name" string in

     
···

       69
       69
        
         content: string;

     

       70
       70
        
         content_type: string;

     

       71
       71
        
         reactions: Reaction.t list;

     

       72
       72
       -
         submessages: Zulip.Zerror.json list;

     

       72
       72
       +
         submessages: Zulip.json list;

     

       73
       73
        
         flags: string list;

     

       74
       74
        
         is_me_message: bool;

     

       75
       75
        
         client: string;

     
···

       91
       91
        
           }

     

       92
       92
        
         | Unknown of {

     

       93
       93
        
             common: common;

     

       94
       94
       -
             raw_json: Zulip.Zerror.json;

     

       94
       94
       +
             raw_json: Zulip.json;

     

       95
       95
        
           }

     

       96
       96
        
       

     

       97
       97
        
       (** Helper function to parse common fields *)

     
···

       115
       115
        
                 match parse_reaction_json r with

     

       116
       116
        
                 | Ok reaction -> Some reaction

     

       117
       117
        
                 | Error err ->

     

       118
       118
       -
                     Log.warn (fun m -> m "Failed to parse reaction: %s" (Zulip.Zerror.message err));

     

       118
       118
       +
                     Log.warn (fun m -> m "Failed to parse reaction: %s" (Zulip.error_message err));

     

       119
       119
        
                     None

     

       120
       120
        
               ) reactions_json

     

       121
       121
        
           | None -> []

     
···

       146
       146
        
       

     

       147
       147
        
         let open Zulip.Jsonu_syntax in

     

       148
       148
        
         match parse_common json with

     

       149
       149
       -
         | Error err -> Error (Zulip.Zerror.message err)

     

       149
       149
       +
         | Error err -> Error (Zulip.error_message err)

     

       150
       150
        
         | Ok common ->

     

       151
       151
        
             (Zulip.Jsonu.parse_with_error "message type" @@ fun () ->

     

       152
       152
        
             (Zulip.Jsonu.with_object "message" @@ fun fields ->

     
···

       157
       157
        
                   match parse_user_json u with

     

       158
       158
        
                   | Ok user -> Some user

     

       159
       159
        
                   | Error err ->

     

       160
       160
       -
                       Log.warn (fun m -> m "Failed to parse user in display_recipient: %s" (Zulip.Zerror.message err));

     

       160
       160
       +
                       Log.warn (fun m -> m "Failed to parse user in display_recipient: %s" (Zulip.error_message err));

     

       161
       161
        
                       None

     

       162
       162
        
                 ) recipient_json in

     

       163
       163
        
       

     
···

       179
       179
        
             | Error _ ->

     

       180
       180
        
                 Log.warn (fun m -> m "No message type field found");

     

       181
       181
        
                 Ok (Unknown { common; raw_json = json })

     

       182
       182
       -
             ) json) |> Result.map_error Zulip.Zerror.message

     

       182
       182
       +
             ) json) |> Result.map_error Zulip.error_message

     

       183
       183
        
       

     

       184
       184
        
       (** Accessor functions *)

     

       185
       185
        
       let get_common = function

+7 -7

stack/zulip/lib/zulip_bot/lib/message.mli

···

       13
       13
        
         val email : t -> string

     

       14
       14
        
         val full_name : t -> string

     

       15
       15
        
         val short_name : t -> string option

     

       16
       16
       -
         val of_json : Zulip.Zerror.json -> (t, Zulip.Zerror.t) result

     

       16
       16
       +
         val of_json : Zulip.json -> (t, Zulip.zerror) result

     

       17
       17
        
       end

     

       18
       18
        
       

     

       19
       19
        
       (** Reaction representation *)

     
···

       29
       29
        
         val emoji_code : t -> string

     

       30
       30
        
         val reaction_type : t -> string

     

       31
       31
        
         val user_id : t -> int

     

       32
       32
       -
         val of_json : Zulip.Zerror.json -> (t, Zulip.Zerror.t) result

     

       32
       32
       +
         val of_json : Zulip.json -> (t, Zulip.zerror) result

     

       33
       33
        
       end

     

       34
       34
        
       

     

       35
       35
        
       (** Common message fields *)

     
···

       43
       43
        
         content: string;

     

       44
       44
        
         content_type: string;

     

       45
       45
        
         reactions: Reaction.t list;

     

       46
       46
       -
         submessages: Zulip.Zerror.json list;

     

       46
       46
       +
         submessages: Zulip.json list;

     

       47
       47
        
         flags: string list;

     

       48
       48
        
         is_me_message: bool;

     

       49
       49
        
         client: string;

     
···

       65
       65
        
           }

     

       66
       66
        
         | Unknown of {

     

       67
       67
        
             common: common;

     

       68
       68
       -
             raw_json: Zulip.Zerror.json;

     

       68
       68
       +
             raw_json: Zulip.json;

     

       69
       69
        
           }

     

       70
       70
        
       

     

       71
       71
        
       (** Accessor functions *)

     
···

       78
       78
        
       val content : t -> string

     

       79
       79
        
       val content_type : t -> string

     

       80
       80
        
       val reactions : t -> Reaction.t list

     

       81
       81
       -
       val submessages : t -> Zulip.Zerror.json list

     

       81
       81
       +
       val submessages : t -> Zulip.json list

     

       82
       82
        
       val flags : t -> string list

     

       83
       83
        
       val is_me_message : t -> bool

     

       84
       84
        
       val client : t -> string

     
···

       99
       99
        
       val parse_command : t -> (string * string list) option

     

       100
       100
        
       

     

       101
       101
        
       (** JSON parsing *)

     

       102
       102
       -
       val of_json : Zulip.Zerror.json -> (t, string) result

     

       102
       102
       +
       val of_json : Zulip.json -> (t, string) result

     

       103
       103
        
       

     

       104
       104
        
       (** Pretty printing *)

     

       105
       105
        
       val pp : Format.formatter -> t -> unit

     
···

       108
       108
        
       val pp_ansi : ?show_json:bool -> Format.formatter -> t -> unit

     

       109
       109
        
       

     

       110
       110
        
       (** Pretty print JSON for debugging *)

     

       111
       111
       -
       val pp_json_debug : Format.formatter -> Zulip.Zerror.json -> unit
     

       111
       111
       +
       val pp_json_debug : Format.formatter -> Zulip.json -> unit

+4 -4

stack/zulip/lib/zulip_botserver/lib/bot_registry.mli

···

       7
       7
        
         val create :

     

       8
       8
        
           name:string ->

     

       9
       9
        
           handler:(module Zulip_bot.Bot_handler.Bot_handler) ->

     

       10
       10
       -
           create_config:(Server_config.Bot_config.t -> (Zulip_bot.Bot_config.t, Zulip.Zerror.t) result) ->

     

       10
       10
       +
           create_config:(Server_config.Bot_config.t -> (Zulip_bot.Bot_config.t, Zulip.zerror) result) ->

     

       11
       11
        
           t

     

       12
       12
        
       

     

       13
       13
        
         val name : t -> string

     

       14
       14
       -
         val create_handler : t -> Server_config.Bot_config.t -> Zulip.Client.t -> (Zulip_bot.Bot_handler.t, Zulip.Zerror.t) result

     

       14
       14
       +
         val create_handler : t -> Server_config.Bot_config.t -> Zulip.Client.t -> (Zulip_bot.Bot_handler.t, Zulip.zerror) result

     

       15
       15
        
       end

     

       16
       16
        
       

     

       17
       17
        
       type t

     
···

       26
       26
        
       val get_bot : t -> email:string -> Zulip_bot.Bot_handler.t option

     

       27
       27
        
       

     

       28
       28
        
       (** Load a bot module from file *)

     

       29
       29
       -
       val load_from_file : string -> (Bot_module.t, Zulip.Zerror.t) result

     

       29
       29
       +
       val load_from_file : string -> (Bot_module.t, Zulip.zerror) result

     

       30
       30
        
       

     

       31
       31
        
       (** Load bot modules from directory *)

     

       32
       32
       -
       val load_from_directory : string -> (Bot_module.t list, Zulip.Zerror.t) result

     

       32
       32
       +
       val load_from_directory : string -> (Bot_module.t list, Zulip.zerror) result

     

       33
       33
        
       

     

       34
       34
        
       (** List all registered bot emails *)

     

       35
       35
        
       val list_bots : t -> string list

+2 -2

stack/zulip/lib/zulip_botserver/lib/bot_server.mli

···

       6
       6
        
       val create : 

     

       7
       7
        
         config:Server_config.t ->

     

       8
       8
        
         registry:Bot_registry.t ->

     

       9
       9
       -
         (t, Zulip.Zerror.t) result

     

       9
       9
       +
         (t, Zulip.zerror) result

     

       10
       10
        
       

     

       11
       11
        
       (** Start the bot server *)

     

       12
       12
        
       val run : t -> unit

     
···

       19
       19
        
         config:Server_config.t ->

     

       20
       20
        
         registry:Bot_registry.t ->

     

       21
       21
        
         (t -> 'a) ->

     

       22
       22
       -
         ('a, Zulip.Zerror.t) result
     

       22
       22
       +
         ('a, Zulip.zerror) result

+2 -2

stack/zulip/lib/zulip_botserver/lib/server_config.mli

···

       30
       30
        
         unit ->

     

       31
       31
        
         t

     

       32
       32
        
       

     

       33
       33
       -
       val from_file : string -> (t, Zulip.Zerror.t) result

     

       34
       34
       -
       val from_env : unit -> (t, Zulip.Zerror.t) result

     

       33
       33
       +
       val from_file : string -> (t, Zulip.zerror) result

     

       34
       34
       +
       val from_env : unit -> (t, Zulip.zerror) result

     

       35
       35
        
       

     

       36
       36
        
       val host : t -> string

     

       37
       37
        
       val port : t -> int

+4 -4

stack/zulip/lib/zulip_botserver/lib/webhook_handler.mli

···

       9
       9
        
         val create : 

     

       10
       10
        
           bot_email:string ->

     

       11
       11
        
           token:string ->

     

       12
       12
       -
           message:Zulip.Zerror.json ->

     

       12
       12
       +
           message:Zulip.json ->

     

       13
       13
        
           trigger:trigger ->

     

       14
       14
        
           t

     

       15
       15
        
           

     

       16
       16
        
         val bot_email : t -> string

     

       17
       17
        
         val token : t -> string

     

       18
       18
       -
         val message : t -> Zulip.Zerror.json

     

       18
       18
       +
         val message : t -> Zulip.json

     

       19
       19
        
         val trigger : t -> trigger

     

       20
       20
        
         val pp : Format.formatter -> t -> unit

     

       21
       21
        
       end

     

       22
       22
        
       

     

       23
       23
        
       (** Parse webhook data from HTTP request *)

     

       24
       24
       -
       val parse_webhook : string -> (Webhook_event.t, Zulip.Zerror.t) result

     

       24
       24
       +
       val parse_webhook : string -> (Webhook_event.t, Zulip.zerror) result

     

       25
       25
        
       

     

       26
       26
        
       (** Process webhook with bot registry *)

     

       27
       27
        
       val handle_webhook : 

     

       28
       28
        
         Bot_registry.t -> 

     

       29
       29
        
         Webhook_event.t -> 

     

       30
       30
       -
         (Zulip_bot.Bot_handler.Response.t option, Zulip.Zerror.t) result

     

       30
       30
       +
         (Zulip_bot.Bot_handler.Response.t option, Zulip.zerror) result

     

       31
       31
        
       

     

       32
       32
        
       (** Validate webhook token *)

     

       33
       33
        
       val validate_token : Server_config.Bot_config.t -> string -> bool