···

       
179
       
 
       
    in

     

       
180
       
 
       
    match Zulip.Messages.send client message with

     

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

     

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

     

       
183
       
 
       


     

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

     

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

     
···

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

     

       
209
       
 
       
      | Ok a -> a

     

       
210
       
 
       
      | Error e ->

     

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

     

       
212
       
 
       
          exit 1

     

       
213
       
 
       
    in

     

       
214
       
 
       


     
···

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

     

       
353
       
 
       
    | Ok a -> a

     

       
354
       
 
       
    | Error e ->

     

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

     

       
356
       
 
       
        exit 1

     

       
357
       
 
       
  in

     

       
358
       
 
       


     

···

       
179
       
 
       
    in

     

       
180
       
 
       
    match Zulip.Messages.send client message with

     

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

     

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

     

       
183
       
 
       


     

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

     

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

     
···

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

     

       
209
       
 
       
      | Ok a -> a

     

       
210
       
 
       
      | Error e ->

     

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

     

       
212
       
 
       
          exit 1

     

       
213
       
 
       
    in

     

       
214
       
 
       


     
···

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

     

       
353
       
 
       
    | Ok a -> a

     

       
354
       
 
       
    | Error e ->

     

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

     

       
356
       
 
       
        exit 1

     

       
357
       
 
       
  in

     

       
358
       
 
       


     

···

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

     

       
39
       
 
       
          | _ -> "unknown format")

     

       
40
       
 
       
   | Error err ->

     

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

     

       
42
       
 
       
  

     

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

     

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

···

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

     

       
39
       
 
       
          | _ -> "unknown format")

     

       
40
       
 
       
   | Error err ->

     

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

     

       
42
       
 
       
  

     

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

     

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

···

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

     

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

     

       
75
       
 
       
                   | Error e ->

     

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

     

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

     

       
78
       
 
       
              | None ->

     

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

     

       
80
       
 
       
            )

     
···

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

     

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

     

       
99
       
 
       
              | Error e ->

     

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

     

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

     

       
102
       
 
       
            )

     

       
103
       
 
       
            else if lower_msg = "list" then (

     

       
104
       
 
       
              (* List all stored keys *)

     
···

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

     

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

     

       
111
       
 
       
              | Error e ->

     

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

     

       
113
       
 
       
            )

     

       
114
       
 
       
            else

     

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

     
···

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

     

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

     

       
164
       
 
       
                   | Error e ->

     

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

     

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

     

       
167
       
 
       
              | None ->

     

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

     

       
169
       
 
       
            )

     
···

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

     

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

     

       
188
       
 
       
              | Error e ->

     

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

     

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

     

       
191
       
 
       
            )

     

       
192
       
 
       
            else if lower_msg = "list" then (

     

       
193
       
 
       
              (* List all stored keys *)

     
···

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

     

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

     

       
200
       
 
       
              | Error e ->

     

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

     

       
202
       
 
       
            )

     

       
203
       
 
       
            else

     

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

     
···

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

     

       
238
       
 
       
        a

     

       
239
       
 
       
    | Error e ->

     

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

     

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

     

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

     

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

     

···

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

     

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

     

       
75
       
 
       
                   | Error e ->

     

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

     

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

     

       
78
       
 
       
              | None ->

     

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

     

       
80
       
 
       
            )

     
···

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

     

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

     

       
99
       
 
       
              | Error e ->

     

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

     

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

     

       
102
       
 
       
            )

     

       
103
       
 
       
            else if lower_msg = "list" then (

     

       
104
       
 
       
              (* List all stored keys *)

     
···

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

     

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

     

       
111
       
 
       
              | Error e ->

     

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

     

       
113
       
 
       
            )

     

       
114
       
 
       
            else

     

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

     
···

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

     

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

     

       
164
       
 
       
                   | Error e ->

     

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

     

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

     

       
167
       
 
       
              | None ->

     

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

     

       
169
       
 
       
            )

     
···

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

     

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

     

       
188
       
 
       
              | Error e ->

     

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

     

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

     

       
191
       
 
       
            )

     

       
192
       
 
       
            else if lower_msg = "list" then (

     

       
193
       
 
       
              (* List all stored keys *)

     
···

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

     

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

     

       
200
       
 
       
              | Error e ->

     

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

     

       
202
       
 
       
            )

     

       
203
       
 
       
            else

     

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

     
···

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

     

       
238
       
 
       
        a

     

       
239
       
 
       
    | Error e ->

     

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

     

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

     

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

     

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

     

···

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

     

       
10
       
 
       
      auth

     

       
11
       
 
       
  | Error e ->

     

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

     

       
13
       
 
       
      (* Create a test auth *)

     

       
14
       
 
       
      Zulip.Auth.create

     

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

     
···

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

     

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

     

       
38
       
 
       
  | Error e ->

     

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

     

       
40
       
 
       


     

       
41
       
 
       
let test_fetch_messages env auth =

     

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

     
···

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

     

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

     

       
57
       
 
       
  | Error e ->

     

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

     

       
59
       
 
       


     

       
60
       
 
       
let () =

     

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

     

···

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

     

       
10
       
 
       
      auth

     

       
11
       
 
       
  | Error e ->

     

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

     

       
13
       
 
       
      (* Create a test auth *)

     

       
14
       
 
       
      Zulip.Auth.create

     

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

     
···

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

     

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

     

       
38
       
 
       
  | Error e ->

     

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

     

       
40
       
 
       


     

       
41
       
 
       
let test_fetch_messages env auth =

     

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

     
···

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

     

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

     

       
57
       
 
       
  | Error e ->

     

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

     

       
59
       
 
       


     

       
60
       
 
       
let () =

     

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

     

···

       
36
       
 
       


     

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

     

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

     

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

     

       
40
       
 
       


     

       
41
       
 
       
    (* Always reply with confirmation *)

     

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

     
···

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

     

       
63
       
 
       
        a

     

       
64
       
 
       
    | Error e ->

     

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

     

       
66
       
 
       
        exit 1

     

       
67
       
 
       
  in

     

       
68
       
 
       


     

···

       
36
       
 
       


     

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

     

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

     

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

     

       
40
       
 
       


     

       
41
       
 
       
    (* Always reply with confirmation *)

     

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

     
···

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

     

       
63
       
 
       
        a

     

       
64
       
 
       
    | Error e ->

     

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

     

       
66
       
 
       
        exit 1

     

       
67
       
 
       
  in

     

       
68
       
 
       


     

···

       
65
       
 
       
        in

     

       
66
       
 
       
        Ok { server_url; email; api_key }

     

       
67
       
 
       
    | _ ->

     

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

     

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

     

       
70
       
 
       
  with

     

       
71
       
 
       
  | Sys_error msg ->

     

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

     

       
73
       
 
       
  | exn ->

     

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

     

       
75
       
 
       


     

       
76
       
 
       
let server_url t = t.server_url

     

       
77
       
 
       
let email t = t.email

     

···

       
65
       
 
       
        in

     

       
66
       
 
       
        Ok { server_url; email; api_key }

     

       
67
       
 
       
    | _ ->

     

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

     

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

     

       
70
       
 
       
  with

     

       
71
       
 
       
  | Sys_error msg ->

     

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

     

       
73
       
 
       
  | exn ->

     

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

     

       
75
       
 
       


     

       
76
       
 
       
let server_url t = t.server_url

     

       
77
       
 
       
let email t = t.email

     

···

       
1
       
 
       
type t

     

       
2
       
 
       


     

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

     

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

     

       
5
       
 
       
val server_url : t -> string

     

       
6
       
 
       
val email : t -> string

     

       
7
       
 
       
val to_basic_auth_header : t -> string

     

···

       
1
       
 
       
type t

     

       
2
       
 
       


     

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

     

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

     

       
5
       
 
       
val server_url : t -> string

     

       
6
       
 
       
val email : t -> string

     

       
7
       
 
       
val to_basic_auth_header : t -> string

     

···

       
42
       
 
       
        

     

       
43
       
 
       
        Ok { name; description; invite_only; history_public_to_subscribers }

     

       
44
       
 
       
    | _ -> 

     

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

     

       
46
       
 
       
  with

     

       
47
       
 
       
  | exn ->

     

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

     

       
49
       
 
       


     

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

···

       
42
       
 
       
        

     

       
43
       
 
       
        Ok { name; description; invite_only; history_public_to_subscribers }

     

       
44
       
 
       
    | _ -> 

     

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

     

       
46
       
 
       
  with

     

       
47
       
 
       
  | exn ->

     

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

     

       
49
       
 
       


     

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

···

       
11
       
 
       
val description : t -> string

     

       
12
       
 
       
val invite_only : t -> bool

     

       
13
       
 
       
val history_public_to_subscribers : t -> bool

     

       
14
       
-
       
val to_json : t -> Zerror.json

     

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

     

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

···

       
11
       
 
       
val description : t -> string

     

       
12
       
 
       
val invite_only : t -> bool

     

       
13
       
 
       
val history_public_to_subscribers : t -> bool

     

       
14
       
+
       
val to_json : t -> Zulip_types.json

     

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

     

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

···

       
31
       
 
       
                  | Error _ -> acc

     

       
32
       
 
       
                ) [] channel_list in

     

       
33
       
 
       
                Ok (List.rev channels)

     

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

     

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

     

       
36
       
 
       
  | Error err -> Error err

     

       
37
       
 
       


     

       
38
       
 
       
let subscribe client ~channels = 

     

···

       
31
       
 
       
                  | Error _ -> acc

     

       
32
       
 
       
                ) [] channel_list in

     

       
33
       
 
       
                Ok (List.rev channels)

     

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

     

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

     

       
36
       
 
       
  | Error err -> Error err

     

       
37
       
 
       


     

       
38
       
 
       
let subscribe client ~channels = 

     

···

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

     

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

     

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

     

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

     

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

···

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

     

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

     

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

     

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

     

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

···

       
134
       
 
       
             | _ -> "Unknown error"

     

       
135
       
 
       
           in

     

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

     

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

     

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

     

       
139
       
 
       
           in

     

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

     

       
141
       
-
       
             (Zerror.code_to_string code));

     

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

     

       
143
       
 
       
       | _ ->

     

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

     

       
145
       
 
       
             Ok json

     

       
146
       
 
       
           else

     

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

     

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

     

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

     

       
150
       
 
       
  | _ ->

     

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

     

       
152
       
 
       
        Ok json

     

       
153
       
 
       
      else

     

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

     

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

     

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

     

       
157
       
 
       


     

       
158
       
 
       
let pp fmt t =

     

···

       
134
       
 
       
             | _ -> "Unknown error"

     

       
135
       
 
       
           in

     

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

     

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

     

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

     

       
139
       
 
       
           in

     

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

     

       
141
       
+
       
             (Zulip_types.error_code_to_string code));

     

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

     

       
143
       
 
       
       | _ ->

     

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

     

       
145
       
 
       
             Ok json

     

       
146
       
 
       
           else

     

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

     

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

     

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

     

       
150
       
 
       
  | _ ->

     

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

     

       
152
       
 
       
        Ok json

     

       
153
       
 
       
      else

     

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

     

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

     

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

     

       
157
       
 
       


     

       
158
       
 
       
let pp fmt t =

     

···

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

     

       
25
       
 
       
  ?body:string ->

     

       
26
       
 
       
  unit ->

     

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

     

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

     

       
29
       
 
       


     

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

     

···

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

     

       
25
       
 
       
  ?body:string ->

     

       
26
       
 
       
  unit ->

     

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

     

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

     

       
29
       
 
       


     

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

     

···

       
1
       
 
       
type t = {

     

       
2
       
 
       
  id : int;

     

       
3
       
 
       
  type_ : Event_type.t;

     

       
4
       
-
       
  data : Zerror.json;

     

       
5
       
 
       
}

     

       
6
       
 
       


     

       
7
       
 
       
let id t = t.id

     
···

       
28
       
 
       


     

       
29
       
 
       
        Ok { id; type_; data }

     

       
30
       
 
       
    | _ -> 

     

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

     

       
32
       
 
       
  with

     

       
33
       
 
       
  | exn ->

     

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

     

       
35
       
 
       


     

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

···

       
1
       
 
       
type t = {

     

       
2
       
 
       
  id : int;

     

       
3
       
 
       
  type_ : Event_type.t;

     

       
4
       
+
       
  data : Zulip_types.json;

     

       
5
       
 
       
}

     

       
6
       
 
       


     

       
7
       
 
       
let id t = t.id

     
···

       
28
       
 
       


     

       
29
       
 
       
        Ok { id; type_; data }

     

       
30
       
 
       
    | _ -> 

     

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

     

       
32
       
 
       
  with

     

       
33
       
 
       
  | exn ->

     

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

     

       
35
       
 
       


     

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

···

       
2
       
 
       


     

       
3
       
 
       
val id : t -> int

     

       
4
       
 
       
val type_ : t -> Event_type.t

     

       
5
       
-
       
val data : t -> Zerror.json

     

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

     

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

···

       
2
       
 
       


     

       
3
       
 
       
val id : t -> int

     

       
4
       
 
       
val type_ : t -> Event_type.t

     

       
5
       
+
       
val data : t -> Zulip_types.json

     

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

     

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

···

       
23
       
 
       
       | `O fields ->

     

       
24
       
 
       
           (match List.assoc_opt "queue_id" fields with

     

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

     

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

     

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

     

       
28
       
 
       
  | Error err -> Error err

     

       
29
       
 
       


     

       
30
       
 
       
let id t = t.id

     
···

       
45
       
 
       
                  match Event.of_json event_json with

     

       
46
       
 
       
                  | Ok event -> event :: acc

     

       
47
       
 
       
                  | Error e ->

     

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

     

       
49
       
 
       
                      acc

     

       
50
       
 
       
                ) [] event_list in

     

       
51
       
 
       
                Ok (List.rev events)

     

       
52
       
 
       
            | Some _other ->

     

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

     

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

     

       
55
       
 
       
            | None ->

     

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

     

       
57
       
 
       
                Ok [])

     

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

     

       
59
       
 
       
  | Error err -> Error err

     

       
60
       
 
       


     

       
61
       
 
       
let delete t client = 

     

···

       
23
       
 
       
       | `O fields ->

     

       
24
       
 
       
           (match List.assoc_opt "queue_id" fields with

     

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

     

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

     

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

     

       
28
       
 
       
  | Error err -> Error err

     

       
29
       
 
       


     

       
30
       
 
       
let id t = t.id

     
···

       
45
       
 
       
                  match Event.of_json event_json with

     

       
46
       
 
       
                  | Ok event -> event :: acc

     

       
47
       
 
       
                  | Error e ->

     

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

     

       
49
       
 
       
                      acc

     

       
50
       
 
       
                ) [] event_list in

     

       
51
       
 
       
                Ok (List.rev events)

     

       
52
       
 
       
            | Some _other ->

     

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

     

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

     

       
55
       
 
       
            | None ->

     

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

     

       
57
       
 
       
                Ok [])

     

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

     

       
59
       
 
       
  | Error err -> Error err

     

       
60
       
 
       


     

       
61
       
 
       
let delete t client = 

     

···

       
4
       
 
       
  Client.t ->

     

       
5
       
 
       
  ?event_types:Event_type.t list ->

     

       
6
       
 
       
  unit ->

     

       
7
       
-
       
  (t, Zerror.t) result

     

       
8
       
 
       


     

       
9
       
 
       
val id : t -> string

     

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

     

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

     

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

···

       
4
       
 
       
  Client.t ->

     

       
5
       
 
       
  ?event_types:Event_type.t list ->

     

       
6
       
 
       
  unit ->

     

       
7
       
+
       
  (t, Zulip_types.zerror) result

     

       
8
       
 
       


     

       
9
       
 
       
val id : t -> string

     

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

     

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

     

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

···

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

     

       
2
       
 
       


     

       
3
       
-
       
open Zerror

     

       
4
       
-
       


     

       
5
       
-
       
type json = Zerror.json

     

       
6
       
 
       


     

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

     

       
8
       
 
       


     

       
9
       
 
       
let get_string fields key =

     

       
10
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
14
       
 
       


     

       
15
       
 
       
let get_string_default fields key default =

     

       
16
       
 
       
  match get_string fields key with

     
···

       
36
       
 
       
  match List.assoc_opt key fields with

     

       
37
       
 
       
  | Some json ->

     

       
38
       
 
       
      (try Ok (to_int_flex json) with

     

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

     

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

     

       
41
       
 
       


     

       
42
       
 
       
let get_int_default fields key default =

     

       
43
       
 
       
  match get_int fields key with

     
···

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

     

       
55
       
 
       
  | Some (`String s) ->

     

       
56
       
 
       
      (try Ok (float_of_string s) with

     

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

     

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

     

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

     

       
60
       
 
       


     

       
61
       
 
       
let get_float_default fields key default =

     

       
62
       
 
       
  match get_float fields key with

     
···

       
66
       
 
       
let get_bool fields key =

     

       
67
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
71
       
 
       


     

       
72
       
 
       
let get_bool_default fields key default =

     

       
73
       
 
       
  match get_bool fields key with

     
···

       
82
       
 
       
let get_object fields key =

     

       
83
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
87
       
 
       


     

       
88
       
 
       
let get_object_opt fields key =

     

       
89
       
 
       
  match List.assoc_opt key fields with

     
···

       
93
       
 
       
let get_array fields key =

     

       
94
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
98
       
 
       


     

       
99
       
 
       
let get_array_opt fields key =

     

       
100
       
 
       
  match List.assoc_opt key fields with

     
···

       
125
       
 
       


     

       
126
       
 
       
let with_object context f = function

     

       
127
       
 
       
  | `O fields -> f fields

     

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

     

       
129
       
 
       


     

       
130
       
 
       
let with_array context f json =

     

       
131
       
 
       
  match json with

     
···

       
138
       
 
       
            | Error e -> Error e

     

       
139
       
 
       
      in

     

       
140
       
 
       
      process [] items

     

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

     

       
142
       
 
       


     

       
143
       
 
       
(** {1 Construction utilities} *)

     

       
144
       
 
       


     
···

       
158
       
 
       
(** {1 Error handling} *)

     

       
159
       
 
       


     

       
160
       
 
       
let json_error msg =

     

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

     

       
162
       
 
       


     

       
163
       
 
       
let field_missing_error field =

     

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

     

       
165
       
 
       


     

       
166
       
 
       
let type_mismatch_error field expected =

     

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

     

       
168
       
 
       


     

       
169
       
 
       
let parse_with_error context f =

     

       
170
       
 
       
  try f ()

     

       
171
       
 
       
  with

     

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

     

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

     

       
174
       
 
       


     

       
175
       
 
       


     

       
176
       
 
       
(** {1 Debugging utilities} *)

     

···

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

     

       
2
       
 
       


     

       
3
       
+
       
type json = Zulip_types.json

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4
       
 
       


     

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

     

       
6
       
 
       


     

       
7
       
 
       
let get_string fields key =

     

       
8
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
12
       
 
       


     

       
13
       
 
       
let get_string_default fields key default =

     

       
14
       
 
       
  match get_string fields key with

     
···

       
34
       
 
       
  match List.assoc_opt key fields with

     

       
35
       
 
       
  | Some json ->

     

       
36
       
 
       
      (try Ok (to_int_flex json) with

     

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

     

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

     

       
39
       
 
       


     

       
40
       
 
       
let get_int_default fields key default =

     

       
41
       
 
       
  match get_int fields key with

     
···

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

     

       
53
       
 
       
  | Some (`String s) ->

     

       
54
       
 
       
      (try Ok (float_of_string s) with

     

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

     

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

     

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

     

       
58
       
 
       


     

       
59
       
 
       
let get_float_default fields key default =

     

       
60
       
 
       
  match get_float fields key with

     
···

       
64
       
 
       
let get_bool fields key =

     

       
65
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
69
       
 
       


     

       
70
       
 
       
let get_bool_default fields key default =

     

       
71
       
 
       
  match get_bool fields key with

     
···

       
80
       
 
       
let get_object fields key =

     

       
81
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
85
       
 
       


     

       
86
       
 
       
let get_object_opt fields key =

     

       
87
       
 
       
  match List.assoc_opt key fields with

     
···

       
91
       
 
       
let get_array fields key =

     

       
92
       
 
       
  match List.assoc_opt key fields with

     

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

     

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

     

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

     

       
96
       
 
       


     

       
97
       
 
       
let get_array_opt fields key =

     

       
98
       
 
       
  match List.assoc_opt key fields with

     
···

       
123
       
 
       


     

       
124
       
 
       
let with_object context f = function

     

       
125
       
 
       
  | `O fields -> f fields

     

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

     

       
127
       
 
       


     

       
128
       
 
       
let with_array context f json =

     

       
129
       
 
       
  match json with

     
···

       
136
       
 
       
            | Error e -> Error e

     

       
137
       
 
       
      in

     

       
138
       
 
       
      process [] items

     

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

     

       
140
       
 
       


     

       
141
       
 
       
(** {1 Construction utilities} *)

     

       
142
       
 
       


     
···

       
156
       
 
       
(** {1 Error handling} *)

     

       
157
       
 
       


     

       
158
       
 
       
let json_error msg =

     

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

     

       
160
       
 
       


     

       
161
       
 
       
let field_missing_error field =

     

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

     

       
163
       
 
       


     

       
164
       
 
       
let type_mismatch_error field expected =

     

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

     

       
166
       
 
       


     

       
167
       
 
       
let parse_with_error context f =

     

       
168
       
 
       
  try f ()

     

       
169
       
 
       
  with

     

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

     

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

     

       
172
       
 
       


     

       
173
       
 
       


     

       
174
       
 
       
(** {1 Debugging utilities} *)

     

···

       
5
       
 
       


     

       
6
       
 
       
(** {1 Type definitions} *)

     

       
7
       
 
       


     

       
8
       
-
       
type json = Zerror.json

     

       
9
       
 
       


     

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

     

       
11
       
 
       


     

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

     

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

     

       
14
       
 
       


     

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

     

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

     
···

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

     

       
20
       
 
       


     

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

     

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

     

       
23
       
 
       


     

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

     

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

     
···

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

     

       
29
       
 
       


     

       
30
       
 
       
(** Extract a float field *)

     

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

     

       
32
       
 
       


     

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

     

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

     

       
35
       
 
       


     

       
36
       
 
       
(** Extract a boolean field *)

     

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

     

       
38
       
 
       


     

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

     

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

     
···

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

     

       
44
       
 
       


     

       
45
       
 
       
(** Extract a JSON object field *)

     

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

     

       
47
       
 
       


     

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

     

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

     

       
50
       
 
       


     

       
51
       
 
       
(** Extract a JSON array field *)

     

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

     

       
53
       
 
       


     

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

     

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

     
···

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

     

       
75
       
 
       


     

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

     

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

     

       
78
       
 
       


     

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

     

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

     

       
81
       
 
       


     

       
82
       
 
       
(** {1 Construction utilities} *)

     

       
83
       
 
       


     
···

       
96
       
 
       
(** {1 Error handling} *)

     

       
97
       
 
       


     

       
98
       
 
       
(** Create a JSON parsing error *)

     

       
99
       
-
       
val json_error : string -> Zerror.t

     

       
100
       
 
       


     

       
101
       
 
       
(** Create a field missing error *)

     

       
102
       
-
       
val field_missing_error : string -> Zerror.t

     

       
103
       
 
       


     

       
104
       
 
       
(** Create a type mismatch error *)

     

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

     

       
106
       
 
       


     

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

     

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

     

       
109
       
 
       


     

       
110
       
 
       


     

       
111
       
 
       
(** {1 Debugging utilities} *)

     

···

       
5
       
 
       


     

       
6
       
 
       
(** {1 Type definitions} *)

     

       
7
       
 
       


     

       
8
       
+
       
type json = Zulip_types.json

     

       
9
       
 
       


     

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

     

       
11
       
 
       


     

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

     

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

     

       
14
       
 
       


     

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

     

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

     
···

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

     

       
20
       
 
       


     

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

     

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

     

       
23
       
 
       


     

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

     

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

     
···

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

     

       
29
       
 
       


     

       
30
       
 
       
(** Extract a float field *)

     

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

     

       
32
       
 
       


     

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

     

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

     

       
35
       
 
       


     

       
36
       
 
       
(** Extract a boolean field *)

     

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

     

       
38
       
 
       


     

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

     

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

     
···

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

     

       
44
       
 
       


     

       
45
       
 
       
(** Extract a JSON object field *)

     

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

     

       
47
       
 
       


     

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

     

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

     

       
50
       
 
       


     

       
51
       
 
       
(** Extract a JSON array field *)

     

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

     

       
53
       
 
       


     

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

     

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

     
···

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

     

       
75
       
 
       


     

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

     

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

     

       
78
       
 
       


     

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

     

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

     

       
81
       
 
       


     

       
82
       
 
       
(** {1 Construction utilities} *)

     

       
83
       
 
       


     
···

       
96
       
 
       
(** {1 Error handling} *)

     

       
97
       
 
       


     

       
98
       
 
       
(** Create a JSON parsing error *)

     

       
99
       
+
       
val json_error : string -> Zulip_types.zerror

     

       
100
       
 
       


     

       
101
       
 
       
(** Create a field missing error *)

     

       
102
       
+
       
val field_missing_error : string -> Zulip_types.zerror

     

       
103
       
 
       


     

       
104
       
 
       
(** Create a type mismatch error *)

     

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

     

       
106
       
 
       


     

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

     

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

     

       
109
       
 
       


     

       
110
       
 
       


     

       
111
       
 
       
(** {1 Debugging utilities} *)

     

···

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

     

       
2
       
 
       


     

       
3
       
-
       
open Zerror

     

       
4
       
-
       


     

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

     

       
6
       
 
       


     

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

     

       
8
       
 
       
let ( let* ) = Result.bind

     
···

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

     

       
50
       
 
       
let required name = function

     

       
51
       
 
       
  | Some v -> Ok v

     

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

     

       
53
       
 
       


     

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

     

       
55
       
 
       
let default v = function

     
···

       
60
       
 
       
let pure x = Ok x

     

       
61
       
 
       


     

       
62
       
 
       
(** Fail with an error message *)

     

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

     

       
64
       
 
       


     

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

     

       
66
       
 
       
let traverse f lst =

     
···

       
107
       
 
       
(** Common parsers *)

     

       
108
       
 
       
let string = function

     

       
109
       
 
       
  | `String s -> Ok s

     

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

     

       
111
       
 
       


     

       
112
       
 
       
let int = function

     

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

     

       
114
       
 
       
  | `String s ->

     

       
115
       
 
       
      (try Ok (int_of_string s)

     

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

     

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

     

       
118
       
 
       


     

       
119
       
 
       
let float = function

     

       
120
       
 
       
  | `Float f -> Ok f

     

       
121
       
 
       
  | `String s ->

     

       
122
       
 
       
      (try Ok (float_of_string s)

     

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

     

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

     

       
125
       
 
       


     

       
126
       
 
       
let bool = function

     

       
127
       
 
       
  | `Bool b -> Ok b

     

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

     

       
129
       
 
       


     

       
130
       
 
       
let array parser = function

     

       
131
       
 
       
  | `A items -> traverse parser items

     

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

     

       
133
       
 
       


     

       
134
       
 
       
let object_ = function

     

       
135
       
 
       
  | `O fields -> Ok fields

     

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

     

       
137
       
 
       


     

       
138
       
 
       
(** Run a parser on JSON *)

     

       
139
       
 
       
let parse parser json = parser json

     
···

       
142
       
 
       
let with_context ctx parser json =

     

       
143
       
 
       
  match parser json with

     

       
144
       
 
       
  | Ok v -> Ok v

     

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

···

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

     

       
2
       
 
       


     

       
3
       
+
       
type json = Zulip_types.json

     

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

     

       
0
       
 
       

     

       
5
       
 
       


     

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

     

       
7
       
 
       
let ( let* ) = Result.bind

     
···

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

     

       
49
       
 
       
let required name = function

     

       
50
       
 
       
  | Some v -> Ok v

     

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

     

       
52
       
 
       


     

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

     

       
54
       
 
       
let default v = function

     
···

       
59
       
 
       
let pure x = Ok x

     

       
60
       
 
       


     

       
61
       
 
       
(** Fail with an error message *)

     

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

     

       
63
       
 
       


     

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

     

       
65
       
 
       
let traverse f lst =

     
···

       
106
       
 
       
(** Common parsers *)

     

       
107
       
 
       
let string = function

     

       
108
       
 
       
  | `String s -> Ok s

     

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

     

       
110
       
 
       


     

       
111
       
 
       
let int = function

     

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

     

       
113
       
 
       
  | `String s ->

     

       
114
       
 
       
      (try Ok (int_of_string s)

     

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

     

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

     

       
117
       
 
       


     

       
118
       
 
       
let float = function

     

       
119
       
 
       
  | `Float f -> Ok f

     

       
120
       
 
       
  | `String s ->

     

       
121
       
 
       
      (try Ok (float_of_string s)

     

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

     

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

     

       
124
       
 
       


     

       
125
       
 
       
let bool = function

     

       
126
       
 
       
  | `Bool b -> Ok b

     

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

     

       
128
       
 
       


     

       
129
       
 
       
let array parser = function

     

       
130
       
 
       
  | `A items -> traverse parser items

     

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

     

       
132
       
 
       


     

       
133
       
 
       
let object_ = function

     

       
134
       
 
       
  | `O fields -> Ok fields

     

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

     

       
136
       
 
       


     

       
137
       
 
       
(** Run a parser on JSON *)

     

       
138
       
 
       
let parse parser json = parser json

     
···

       
141
       
 
       
let with_context ctx parser json =

     

       
142
       
 
       
  match parser json with

     

       
143
       
 
       
  | Ok v -> Ok v

     

       
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)) ())
     

···

       
13
       
 
       
    ]}

     

       
14
       
 
       
*)

     

       
15
       
 
       


     

       
16
       
-
       
open Zerror

     

       
17
       
-
       


     

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

     

       
19
       
 
       


     

       
20
       
 
       
(** {1 Binding Operators} *)

     

       
21
       
 
       


     
···

       
42
       
 
       
(** {1 Field Extraction} *)

     

       
43
       
 
       


     

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

     

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

     

       
46
       
 
       


     

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

     

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

     

       
49
       
 
       


     

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

     

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

     

       
52
       
 
       


     

       
53
       
 
       
(** {1 Basic Parsers} *)

     

       
54
       
 
       


     
···

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

     

       
69
       
 
       


     

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

     

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

     

       
72
       
 
       


     

       
73
       
 
       
(** {1 Utility Functions} *)

     

       
74
       
 
       


     

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

     

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

     

       
77
       
 
       


     

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

     

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

     
···

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

     

       
83
       
 
       


     

       
84
       
 
       
(** Fail with an error message *)

     

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

     

       
86
       
 
       


     

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

     

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

     

       
89
       
 
       


     

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

     

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

     

       
92
       
 
       


     

       
93
       
 
       
(** Run a parser on JSON *)

     

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

     

       
95
       
 
       


     

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

     

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

···

       
13
       
 
       
    ]}

     

       
14
       
 
       
*)

     

       
15
       
 
       


     

       
16
       
+
       
type json = Zulip_types.json

     

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

     

       
0
       
 
       

     

       
18
       
 
       


     

       
19
       
 
       
(** {1 Binding Operators} *)

     

       
20
       
 
       


     
···

       
41
       
 
       
(** {1 Field Extraction} *)

     

       
42
       
 
       


     

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

     

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

     

       
45
       
 
       


     

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

     

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

     

       
48
       
 
       


     

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

     

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

     

       
51
       
 
       


     

       
52
       
 
       
(** {1 Basic Parsers} *)

     

       
53
       
 
       


     
···

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

     

       
68
       
 
       


     

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

     

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

     

       
71
       
 
       


     

       
72
       
 
       
(** {1 Utility Functions} *)

     

       
73
       
 
       


     

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

     

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

     

       
76
       
 
       


     

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

     

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

     
···

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

     

       
82
       
 
       


     

       
83
       
 
       
(** Fail with an error message *)

     

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

     

       
85
       
 
       


     

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

     

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

     

       
88
       
 
       


     

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

     

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

     

       
91
       
 
       


     

       
92
       
 
       
(** Run a parser on JSON *)

     

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

     

       
94
       
 
       


     

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

     

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

···

       
17
       
 
       
val queue_id : t -> string option

     

       
18
       
 
       
val local_id : t -> string option

     

       
19
       
 
       
val read_by_sender : t -> bool

     

       
20
       
-
       
val to_json : t -> Zerror.json

     

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

···

       
17
       
 
       
val queue_id : t -> string option

     

       
18
       
 
       
val local_id : t -> string option

     

       
19
       
 
       
val read_by_sender : t -> bool

     

       
20
       
+
       
val to_json : t -> Zulip_types.json

     

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

···

       
2
       
 
       


     

       
3
       
 
       
val id : t -> int

     

       
4
       
 
       
val automatic_new_visibility_policy : t -> string option

     

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

     

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

···

       
2
       
 
       


     

       
3
       
 
       
val id : t -> int

     

       
4
       
 
       
val automatic_new_visibility_policy : t -> string option

     

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

     

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

···

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

     

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

     

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

     

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

     

       
5
       
 
       
val get_messages :

     

       
6
       
 
       
  Client.t ->

     

       
7
       
 
       
  ?anchor:string ->

     
···

       
9
       
 
       
  ?num_after:int ->

     

       
10
       
 
       
  ?narrow:string list ->

     

       
11
       
 
       
  unit ->

     

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

···

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

     

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

     

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

     

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

     

       
5
       
 
       
val get_messages :

     

       
6
       
 
       
  Client.t ->

     

       
7
       
 
       
  ?anchor:string ->

     
···

       
9
       
 
       
  ?num_after:int ->

     

       
10
       
 
       
  ?narrow:string list ->

     

       
11
       
 
       
  unit ->

     

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

···

       
13
       
 
       
val is_active : t -> bool

     

       
14
       
 
       
val is_admin : t -> bool

     

       
15
       
 
       
val is_bot : t -> bool

     

       
16
       
-
       
val to_json : t -> Zerror.json

     

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

     

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

···

       
13
       
 
       
val is_active : t -> bool

     

       
14
       
 
       
val is_admin : t -> bool

     

       
15
       
 
       
val is_bot : t -> bool

     

       
16
       
+
       
val to_json : t -> Zulip_types.json

     

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

     

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

···

       
11
       
 
       
                  | Error _ -> acc

     

       
12
       
 
       
                ) [] user_list in

     

       
13
       
 
       
                Ok (List.rev users)

     

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

     

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

     

       
16
       
 
       
  | Error err -> Error err

     

       
17
       
 
       


     

       
18
       
 
       
let get client ~email = 

     

···

       
11
       
 
       
                  | Error _ -> acc

     

       
12
       
 
       
                ) [] user_list in

     

       
13
       
 
       
                Ok (List.rev users)

     

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

     

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

     

       
16
       
 
       
  | Error err -> Error err

     

       
17
       
 
       


     

       
18
       
 
       
let get client ~email = 

     

···

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

     

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

     

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

     

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

···

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

     

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

     

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

     

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

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

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

     

       
2
       
+
       


     

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

     

       
4
       
+
       
type json = Zulip_types.json

     

       
5
       
+
       
type error_code = Zulip_types.error_code =

     

       
6
       
+
       
  | Invalid_api_key

     

       
7
       
+
       
  | Request_variable_missing

     

       
8
       
+
       
  | Bad_request

     

       
9
       
+
       
  | User_deactivated

     

       
10
       
+
       
  | Realm_deactivated

     

       
11
       
+
       
  | Rate_limit_hit

     

       
12
       
+
       
  | Other of string

     

       
13
       
+
       


     

       
14
       
+
       
type zerror = Zulip_types.zerror = {

     

       
15
       
+
       
  code : error_code;

     

       
16
       
+
       
  message : string;

     

       
17
       
+
       
  extra : (string * json) list;

     

       
18
       
+
       
}

     

       
19
       
+
       


     

       
20
       
+
       
let error_code_to_string = Zulip_types.error_code_to_string

     

       
21
       
+
       
let error_code_of_string = Zulip_types.error_code_of_string

     

       
22
       
+
       
let create_error = Zulip_types.create_error

     

       
23
       
+
       
let error_code = Zulip_types.error_code

     

       
24
       
+
       
let error_message = Zulip_types.error_message

     

       
25
       
+
       
let error_extra = Zulip_types.error_extra

     

       
26
       
+
       
let pp_error = Zulip_types.pp_error

     

       
27
       
+
       
let error_of_json = Zulip_types.error_of_json

     

       
28
       
+
       


     

       
29
       
+
       


     

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

     

       
31
       
+
       
module Auth = Auth

     

       
32
       
+
       
module Client = Client

     

       
33
       
+
       
module Message = Message

     

       
34
       
+
       
module Message_type = Message_type

     

       
35
       
+
       
module Message_response = Message_response

     

       
36
       
+
       
module Messages = Messages

     

       
37
       
+
       
module Channel = Channel

     

       
38
       
+
       
module Channels = Channels

     

       
39
       
+
       
module User = User

     

       
40
       
+
       
module Users = Users

     

       
41
       
+
       
module Event = Event

     

       
42
       
+
       
module Event_type = Event_type

     

       
43
       
+
       
module Event_queue = Event_queue

     

       
44
       
+
       


     

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

     

       
46
       
+
       
module J = Jsonu

     

       
47
       
+
       
module Jsonu_syntax = Jsonu_syntax

     

       
48
       
+
       
module Jsonu = Jsonu
     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
(** Zulip API client library for OCaml

     

       
2
       
+
       


     

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

     

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

     

       
5
       
+
       


     

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

     

       
7
       
+
       


     

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

     

       
9
       
+
       
type json = Zulip_types.json

     

       
10
       
+
       


     

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

     

       
12
       
+
       


     

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

     

       
14
       
+
       
type error_code = Zulip_types.error_code =

     

       
15
       
+
       
  | Invalid_api_key

     

       
16
       
+
       
  | Request_variable_missing

     

       
17
       
+
       
  | Bad_request

     

       
18
       
+
       
  | User_deactivated

     

       
19
       
+
       
  | Realm_deactivated

     

       
20
       
+
       
  | Rate_limit_hit

     

       
21
       
+
       
  | Other of string

     

       
22
       
+
       


     

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

     

       
24
       
+
       
type zerror = Zulip_types.zerror = {

     

       
25
       
+
       
  code : error_code;

     

       
26
       
+
       
  message : string;

     

       
27
       
+
       
  extra : (string * json) list;

     

       
28
       
+
       
}

     

       
29
       
+
       


     

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

     

       
31
       
+
       


     

       
32
       
+
       
val error_code_to_string : error_code -> string

     

       
33
       
+
       
val error_code_of_string : string -> error_code

     

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

     

       
35
       
+
       
val error_code : zerror -> error_code

     

       
36
       
+
       
val error_message : zerror -> string

     

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

     

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

     

       
39
       
+
       
val error_of_json : json -> zerror option

     

       
40
       
+
       


     

       
41
       
+
       
(** {1 Submodules} *)

     

       
42
       
+
       


     

       
43
       
+
       
(** Authentication management *)

     

       
44
       
+
       
module Auth = Auth

     

       
45
       
+
       


     

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

     

       
47
       
+
       
module Client = Client

     

       
48
       
+
       


     

       
49
       
+
       
(** Message types and operations *)

     

       
50
       
+
       
module Message = Message

     

       
51
       
+
       
module Message_type = Message_type

     

       
52
       
+
       
module Message_response = Message_response

     

       
53
       
+
       
module Messages = Messages

     

       
54
       
+
       


     

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

     

       
56
       
+
       
module Channel = Channel

     

       
57
       
+
       
module Channels = Channels

     

       
58
       
+
       


     

       
59
       
+
       
(** User management *)

     

       
60
       
+
       
module User = User

     

       
61
       
+
       
module Users = Users

     

       
62
       
+
       


     

       
63
       
+
       
(** Event handling *)

     

       
64
       
+
       
module Event = Event

     

       
65
       
+
       
module Event_type = Event_type

     

       
66
       
+
       
module Event_queue = Event_queue

     

       
67
       
+
       


     

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

     

       
69
       
+
       


     

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

     

       
71
       
+
       
module J = Jsonu

     

       
72
       
+
       


     

       
73
       
+
       
(** JSON parsing syntax extensions *)

     

       
74
       
+
       
module Jsonu_syntax = Jsonu_syntax

     

       
75
       
+
       


     

       
76
       
+
       
(** Full JSON utilities module *)

     

       
77
       
+
       
module Jsonu = Jsonu

     

       
78
       
+
       


     

···

       
54
       
 
       
    Ok config

     

       
55
       
 
       
  with

     

       
56
       
 
       
  | Sys_error msg ->

     

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

     

       
58
       
 
       
  | exn ->

     

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

     

       
60
       
 
       


     

       
61
       
 
       
let from_env ~prefix =

     

       
62
       
 
       
  try

     
···

       
76
       
 
       
    Ok config

     

       
77
       
 
       
  with

     

       
78
       
 
       
  | exn ->

     

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

     

       
80
       
 
       


     

       
81
       
 
       
let get t ~key =

     

       
82
       
 
       
  Hashtbl.find_opt t key

     
···

       
84
       
 
       
let get_required t ~key =

     

       
85
       
 
       
  match Hashtbl.find_opt t key with

     

       
86
       
 
       
  | Some value -> Ok value

     

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

     

       
88
       
 
       


     

       
89
       
 
       
let has_key t ~key =

     

       
90
       
 
       
  Hashtbl.mem t key

     

···

       
54
       
 
       
    Ok config

     

       
55
       
 
       
  with

     

       
56
       
 
       
  | Sys_error msg ->

     

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

     

       
58
       
 
       
  | exn ->

     

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

     

       
60
       
 
       


     

       
61
       
 
       
let from_env ~prefix =

     

       
62
       
 
       
  try

     
···

       
76
       
 
       
    Ok config

     

       
77
       
 
       
  with

     

       
78
       
 
       
  | exn ->

     

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

     

       
80
       
 
       


     

       
81
       
 
       
let get t ~key =

     

       
82
       
 
       
  Hashtbl.find_opt t key

     
···

       
84
       
 
       
let get_required t ~key =

     

       
85
       
 
       
  match Hashtbl.find_opt t key with

     

       
86
       
 
       
  | Some value -> Ok value

     

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

     

       
88
       
 
       


     

       
89
       
 
       
let has_key t ~key =

     

       
90
       
 
       
  Hashtbl.mem t key