@f3liz/rescript-misskey-api 0.7.0 → 0.8.0

package/lib/es6/src/Misskey.mjs

@@ -71,8 +71,27 @@ async function request(client, endpoint, paramsOpt, param) {
     };
   } catch (raw_err) {
     let err = Primitive_exceptions.internalToException(raw_err);
+    let errorData = err.data;
     let jsExn = Stdlib_JsExn.fromException(err);
-    let msg = jsExn !== undefined ? Stdlib_Option.getOr(Stdlib_JsExn.message(Primitive_option.valFromOption(jsExn)), "Unknown error") : "Unknown error";
+    let baseMsg = jsExn !== undefined ? Stdlib_Option.getOr(Stdlib_JsExn.message(Primitive_option.valFromOption(jsExn)), "Unknown error") : "Unknown error";
+    let msg;
+    if (errorData !== undefined) {
+      let obj = Stdlib_JSON.Decode.object(errorData);
+      if (obj !== undefined) {
+        let errObj = Stdlib_Option.flatMap(obj["error"], Stdlib_JSON.Decode.object);
+        if (errObj !== undefined) {
+          let code = Stdlib_Option.getOr(Stdlib_Option.flatMap(errObj["code"], Stdlib_JSON.Decode.string), "");
+          let message = Stdlib_Option.getOr(Stdlib_Option.flatMap(errObj["message"], Stdlib_JSON.Decode.string), "");
+          msg = baseMsg + ` [` + code + `] ` + message;
+        } else {
+          msg = baseMsg;
+        }
+      } else {
+        msg = baseMsg;
+      }
+    } else {
+      msg = baseMsg;
+    }
     return {
       TAG: "Error",
       _0: msg
@@ -88,12 +107,16 @@ function origin(client) {
   return client.origin;
 }
 
+function token(client) {
+  return client.token;
+}
+
 function close(client) {
   Stdlib_Option.forEach(client.streamClient, StreamClient.close);
   client.streamClient = undefined;
 }
 
-function create(client, text, visibilityOpt, cw, localOnlyOpt, replyId, renoteId, param) {
+function create(client, text, visibilityOpt, cw, localOnlyOpt, replyId, renoteId, fileIds, param) {
   let visibility = visibilityOpt !== undefined ? visibilityOpt : "public";
   let localOnly = localOnlyOpt !== undefined ? localOnlyOpt : false;
   let params = {};
@@ -114,6 +137,9 @@ function create(client, text, visibilityOpt, cw, localOnlyOpt, replyId, renoteId
   Stdlib_Option.forEach(renoteId, v => {
     params["renoteId"] = v;
   });
+  Stdlib_Option.forEach(fileIds, ids => {
+    params["fileIds"] = ids.map(prim => prim);
+  });
   return request(client, "notes/create", params, undefined);
 }
 
@@ -198,13 +224,83 @@ function unreact(client, noteId) {
   return request(client, "notes/reactions/delete", params, undefined);
 }
 
+function show(client, noteId) {
+  let params = {};
+  params["noteId"] = noteId;
+  return request(client, "notes/show", params, undefined);
+}
+
+function children(client, noteId, limitOpt, sinceId, untilId, param) {
+  let limit = limitOpt !== undefined ? limitOpt : 30;
+  let params = {};
+  params["noteId"] = noteId;
+  params["limit"] = limit;
+  Stdlib_Option.forEach(sinceId, v => {
+    params["sinceId"] = v;
+  });
+  Stdlib_Option.forEach(untilId, v => {
+    params["untilId"] = v;
+  });
+  return request(client, "notes/children", params, undefined);
+}
+
+function conversation(client, noteId, limitOpt, param) {
+  let limit = limitOpt !== undefined ? limitOpt : 30;
+  let params = {};
+  params["noteId"] = noteId;
+  params["limit"] = limit;
+  return request(client, "notes/conversation", params, undefined);
+}
+
 let Notes = {
   create: create,
   $$delete: $$delete,
   fetch: fetch,
   timeline: fetch,
   react: react,
-  unreact: unreact
+  unreact: unreact,
+  show: show,
+  children: children,
+  conversation: conversation
+};
+
+function show$1(client, userId, username, host, param) {
+  let params = {};
+  Stdlib_Option.forEach(userId, v => {
+    params["userId"] = v;
+  });
+  Stdlib_Option.forEach(username, v => {
+    params["username"] = v;
+  });
+  Stdlib_Option.forEach(host, v => {
+    params["host"] = v;
+  });
+  return request(client, "users/show", params, undefined);
+}
+
+function notes(client, userId, limitOpt, withRepliesOpt, withRenotesOpt, withFilesOpt, sinceId, untilId, param) {
+  let limit = limitOpt !== undefined ? limitOpt : 20;
+  let withReplies = withRepliesOpt !== undefined ? withRepliesOpt : false;
+  let withRenotes = withRenotesOpt !== undefined ? withRenotesOpt : true;
+  let withFiles = withFilesOpt !== undefined ? withFilesOpt : false;
+  let params = {};
+  params["userId"] = userId;
+  params["limit"] = limit;
+  params["withReplies"] = withReplies;
+  params["withRenotes"] = withRenotes;
+  params["withFiles"] = withFiles;
+  Stdlib_Option.forEach(sinceId, v => {
+    params["sinceId"] = v;
+  });
+  Stdlib_Option.forEach(untilId, v => {
+    params["untilId"] = v;
+  });
+  return request(client, "users/notes", params, undefined);
+}
+
+let Users = {
+  show: show$1,
+  notes: notes
 };
 
 function ensureStream(client) {
@@ -614,6 +710,185 @@ function isPermissionDenied(error) {
   return match === "PERMISSION_DENIED";
 }
 
+async function get(client) {
+  let json = await request(client, "meta", undefined, undefined);
+  if (json.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: json._0
+    };
+  }
+  let obj = Stdlib_JSON.Decode.object(json._0);
+  if (obj !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: {
+        swPublickey: Stdlib_Option.flatMap(obj["swPublickey"], Stdlib_JSON.Decode.string)
+      }
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "Invalid meta response"
+    };
+  }
+}
+
+let Meta = {
+  get: get
+};
+
+async function register(client, endpoint, auth, publickey, sendReadMessageOpt, param) {
+  let sendReadMessage = sendReadMessageOpt !== undefined ? sendReadMessageOpt : false;
+  let params = {};
+  params["endpoint"] = endpoint;
+  params["auth"] = auth;
+  params["publickey"] = publickey;
+  params["sendReadMessage"] = sendReadMessage;
+  let json = await request(client, "sw/register", params, undefined);
+  if (json.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: json._0
+    };
+  }
+  let obj = Stdlib_JSON.Decode.object(json._0);
+  if (obj !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: {
+        state: Stdlib_Option.flatMap(obj["state"], Stdlib_JSON.Decode.string),
+        key: Stdlib_Option.flatMap(obj["key"], Stdlib_JSON.Decode.string),
+        userId: Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["userId"], Stdlib_JSON.Decode.string), ""),
+        endpoint: Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["endpoint"], Stdlib_JSON.Decode.string), ""),
+        sendReadMessage: Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["sendReadMessage"], Stdlib_JSON.Decode.bool), false)
+      }
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "Invalid sw/register response"
+    };
+  }
+}
+
+async function unregister(client, endpoint) {
+  let params = {};
+  params["endpoint"] = endpoint;
+  let e = await request(client, "sw/unregister", params, undefined);
+  if (e.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: e._0
+    };
+  }
+}
+
+let Sw = {
+  register: register,
+  unregister: unregister
+};
+
+async function create$1(client, name, url, secret, on, param) {
+  let params = {};
+  params["name"] = name;
+  params["url"] = url;
+  params["secret"] = secret;
+  params["on"] = on.map(prim => prim);
+  let json = await request(client, "i/webhooks/create", params, undefined);
+  if (json.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: json._0
+    };
+  }
+  let obj = Stdlib_JSON.Decode.object(json._0);
+  if (obj === undefined) {
+    return {
+      TAG: "Error",
+      _0: "Invalid webhook response"
+    };
+  }
+  let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["id"], Stdlib_JSON.Decode.string), "");
+  let name$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["name"], Stdlib_JSON.Decode.string), "");
+  let url$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["url"], Stdlib_JSON.Decode.string), "");
+  let active = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["active"], Stdlib_JSON.Decode.bool), false);
+  return {
+    TAG: "Ok",
+    _0: {
+      id: id,
+      name: name$1,
+      url: url$1,
+      active: active
+    }
+  };
+}
+
+async function $$delete$1(client, webhookId) {
+  let params = {};
+  params["webhookId"] = webhookId;
+  let e = await request(client, "i/webhooks/delete", params, undefined);
+  if (e.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: e._0
+    };
+  }
+}
+
+async function list$1(client) {
+  let json = await request(client, "i/webhooks/list", undefined, undefined);
+  if (json.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: json._0
+    };
+  }
+  let arr = Stdlib_JSON.Decode.array(json._0);
+  if (arr !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: Stdlib_Array.filterMap(arr, item => {
+        let obj = Stdlib_JSON.Decode.object(item);
+        if (obj === undefined) {
+          return;
+        }
+        let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["id"], Stdlib_JSON.Decode.string), "");
+        let name = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["name"], Stdlib_JSON.Decode.string), "");
+        let url = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["url"], Stdlib_JSON.Decode.string), "");
+        let active = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["active"], Stdlib_JSON.Decode.bool), false);
+        return {
+          id: id,
+          name: name,
+          url: url,
+          active: active
+        };
+      })
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+}
+
+let Webhooks = {
+  create: create$1,
+  $$delete: $$delete$1,
+  list: list$1
+};
+
 function isAPIError(error) {
   let obj = Stdlib_JSON.Decode.object(error);
   if (obj === undefined) {
@@ -631,6 +906,61 @@ function isAPIError(error) {
   }
 }
 
+async function upload(client, file, sensitiveOpt, param) {
+  let sensitive = sensitiveOpt !== undefined ? sensitiveOpt : false;
+  try {
+    let fd = (new FormData());
+    fd.append("file", file);
+    Stdlib_Option.forEach(client.token, tok => fd.append("i", tok));
+    if (sensitive) {
+      fd.append("isSensitive", "true");
+    }
+    let endpoint = client.origin + "/api/drive/files/create";
+    let json = await Ofetch.ofetch(endpoint, {
+      method: "POST",
+      body: fd
+    });
+    let idJson = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), obj => obj["id"]);
+    if (idJson !== undefined) {
+      let id = Stdlib_JSON.Decode.string(idJson);
+      if (id !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: id
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: "Drive upload: id is not a string"
+        };
+      }
+    }
+    let errDetail = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), obj => obj["error"]), Stdlib_JSON.Decode.object), obj => obj["message"]), Stdlib_JSON.Decode.string);
+    let statusCode = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), obj => obj["error"]), Stdlib_JSON.Decode.object), obj => obj["code"]), Stdlib_JSON.Decode.string);
+    let msg = statusCode !== undefined ? (
+        errDetail !== undefined ? statusCode + ": " + errDetail : "Upload error: " + statusCode
+      ) : (
+        errDetail !== undefined ? errDetail : "Unknown upload error"
+      );
+    return {
+      TAG: "Error",
+      _0: msg
+    };
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    let jsExn = Stdlib_JsExn.fromException(err);
+    let msg$1 = jsExn !== undefined ? Stdlib_Option.getOr(Stdlib_JsExn.message(Primitive_option.valFromOption(jsExn)), "Drive upload failed") : "Drive upload failed";
+    return {
+      TAG: "Error",
+      _0: msg$1
+    };
+  }
+}
+
+let Drive = {
+  upload: upload
+};
+
 let $$default = connect;
 
 export {
@@ -641,14 +971,20 @@ export {
   request,
   currentUser,
   origin,
+  token,
   close,
   Notes,
+  Users,
   Stream,
   Emojis,
   CustomTimelines,
   MiAuth,
   isPermissionDenied,
+  Meta,
+  Sw,
+  Webhooks,
   isAPIError,
+  Drive,
   $$default as default,
 }
 /*  Not a pure module */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-misskey-api",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "ReScript bindings for Misskey API using OpenAPI code generation",
   "keywords": [
     "misskey",

package/src/Misskey.res

@@ -117,10 +117,29 @@ let request = async (
     Ok(json)
   } catch {
   | err =>
-    let msg = switch err->JsExn.fromException {
+    // ofetch attaches response data to error.data for non-2xx responses
+    let errorData: option<JSON.t> = (err->Obj.magic)["data"]
+    let baseMsg = switch err->JsExn.fromException {
     | Some(jsExn) => JsExn.message(jsExn)->Option.getOr("Unknown error")
     | None => "Unknown error"
     }
+    let msg = switch errorData {
+    | Some(data) =>
+      switch data->JSON.Decode.object {
+      | Some(obj) =>
+        switch obj->Dict.get("error")->Option.flatMap(JSON.Decode.object) {
+        | Some(errObj) =>
+          let code =
+            errObj->Dict.get("code")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+          let message =
+            errObj->Dict.get("message")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+          `${baseMsg} [${code}] ${message}`
+        | None => baseMsg
+        }
+      | None => baseMsg
+      }
+    | None => baseMsg
+    }
     Error(msg)
   }
 }
@@ -133,6 +152,9 @@ let currentUser = (client: t): promise<result<JSON.t, string>> => {
 /// Get client origin (instance URL).
 let origin = (client: t): string => client.origin
 
+/// Get client authentication token.
+let token = (client: t): option<string> => client.token
+
 /// Close client and cleanup (close streaming connections).
 let close = (client: t): unit => {
   client.streamClient->Option.forEach(s => s->StreamClient.close)
@@ -165,6 +187,7 @@ module Notes = {
     ~localOnly: bool=false,
     ~replyId: option<string>=?,
     ~renoteId: option<string>=?,
+    ~fileIds: option<array<string>>=?,
     (),
   ): promise<result<JSON.t, string>> => {
     let params = Dict.make()
@@ -182,6 +205,9 @@ module Notes = {
     cw->Option.forEach(v => params->Dict.set("cw", v->JSON.Encode.string))
     replyId->Option.forEach(v => params->Dict.set("replyId", v->JSON.Encode.string))
     renoteId->Option.forEach(v => params->Dict.set("renoteId", v->JSON.Encode.string))
+    fileIds->Option.forEach(ids =>
+      params->Dict.set("fileIds", ids->Array.map(JSON.Encode.string)->JSON.Encode.array)
+    )
 
     request(client, "notes/create", ~params=params->JSON.Encode.object, ())
   }
@@ -257,12 +283,89 @@ module Notes = {
     params->Dict.set("noteId", noteId->JSON.Encode.string)
     request(client, "notes/reactions/delete", ~params=params->JSON.Encode.object, ())
   }
+
+  /// Get a single note by ID.
+  let show = (client: t, noteId: string): promise<result<JSON.t, string>> => {
+    let params = Dict.make()
+    params->Dict.set("noteId", noteId->JSON.Encode.string)
+    request(client, "notes/show", ~params=params->JSON.Encode.object, ())
+  }
+
+  /// Get replies/children of a note.
+  let children = (
+    client: t,
+    noteId: string,
+    ~limit: int=30,
+    ~sinceId: option<string>=?,
+    ~untilId: option<string>=?,
+    (),
+  ): promise<result<JSON.t, string>> => {
+    let params = Dict.make()
+    params->Dict.set("noteId", noteId->JSON.Encode.string)
+    params->Dict.set("limit", limit->JSON.Encode.int)
+    sinceId->Option.forEach(v => params->Dict.set("sinceId", v->JSON.Encode.string))
+    untilId->Option.forEach(v => params->Dict.set("untilId", v->JSON.Encode.string))
+    request(client, "notes/children", ~params=params->JSON.Encode.object, ())
+  }
+
+  /// Get the conversation thread (parent notes) for a note.
+  let conversation = (
+    client: t,
+    noteId: string,
+    ~limit: int=30,
+    (),
+  ): promise<result<JSON.t, string>> => {
+    let params = Dict.make()
+    params->Dict.set("noteId", noteId->JSON.Encode.string)
+    params->Dict.set("limit", limit->JSON.Encode.int)
+    request(client, "notes/conversation", ~params=params->JSON.Encode.object, ())
+  }
 }
 
 // ============================================================================
-// Stream API - Real-time updates via WebSocket
+// Users API
 // ============================================================================
 
+module Users = {
+  /// Get user profile by username (and optional host for remote users).
+  let show = (
+    client: t,
+    ~userId: option<string>=?,
+    ~username: option<string>=?,
+    ~host: option<string>=?,
+    (),
+  ): promise<result<JSON.t, string>> => {
+    let params = Dict.make()
+    userId->Option.forEach(v => params->Dict.set("userId", v->JSON.Encode.string))
+    username->Option.forEach(v => params->Dict.set("username", v->JSON.Encode.string))
+    host->Option.forEach(v => params->Dict.set("host", v->JSON.Encode.string))
+    request(client, "users/show", ~params=params->JSON.Encode.object, ())
+  }
+
+  /// Get notes posted by a user.
+  let notes = (
+    client: t,
+    userId: string,
+    ~limit: int=20,
+    ~withReplies: bool=false,
+    ~withRenotes: bool=true,
+    ~withFiles: bool=false,
+    ~sinceId: option<string>=?,
+    ~untilId: option<string>=?,
+    (),
+  ): promise<result<JSON.t, string>> => {
+    let params = Dict.make()
+    params->Dict.set("userId", userId->JSON.Encode.string)
+    params->Dict.set("limit", limit->JSON.Encode.int)
+    params->Dict.set("withReplies", withReplies->JSON.Encode.bool)
+    params->Dict.set("withRenotes", withRenotes->JSON.Encode.bool)
+    params->Dict.set("withFiles", withFiles->JSON.Encode.bool)
+    sinceId->Option.forEach(v => params->Dict.set("sinceId", v->JSON.Encode.string))
+    untilId->Option.forEach(v => params->Dict.set("untilId", v->JSON.Encode.string))
+    request(client, "users/notes", ~params=params->JSON.Encode.object, ())
+  }
+}
+
 module Stream = {
   type subscription = {dispose: unit => unit}
 
@@ -660,6 +763,166 @@ let isPermissionDenied = (error: JSON.t): bool => {
 }
 
 /// Check if error is an API error and extract error info.
+// ============================================================================
+// Instance Meta API
+// ============================================================================
+
+module Meta = {
+  type meta = {
+    swPublickey: option<string>,
+  }
+
+  /// Get instance metadata (includes VAPID public key for push notifications).
+  let get = async (client: t): result<meta, string> => {
+    switch await request(client, "meta", ()) {
+    | Ok(json) =>
+      switch json->JSON.Decode.object {
+      | Some(obj) =>
+        Ok({
+          swPublickey: obj
+          ->Dict.get("swPublickey")
+          ->Option.flatMap(JSON.Decode.string),
+        })
+      | None => Error("Invalid meta response")
+      }
+    | Error(e) => Error(e)
+    }
+  }
+}
+
+// ============================================================================
+// Service Worker (Push Notification) API
+// ============================================================================
+
+module Sw = {
+  type registration = {
+    state: option<string>,
+    key: option<string>,
+    userId: string,
+    endpoint: string,
+    sendReadMessage: bool,
+  }
+
+  /// Register a push notification endpoint with the Misskey instance.
+  let register = async (
+    client: t,
+    ~endpoint: string,
+    ~auth: string,
+    ~publickey: string,
+    ~sendReadMessage: bool=false,
+    (),
+  ): result<registration, string> => {
+    let params = Dict.make()
+    params->Dict.set("endpoint", endpoint->JSON.Encode.string)
+    params->Dict.set("auth", auth->JSON.Encode.string)
+    params->Dict.set("publickey", publickey->JSON.Encode.string)
+    params->Dict.set("sendReadMessage", sendReadMessage->JSON.Encode.bool)
+    switch await request(client, "sw/register", ~params=params->JSON.Encode.object, ()) {
+    | Ok(json) =>
+      switch json->JSON.Decode.object {
+      | Some(obj) =>
+        Ok({
+          state: obj->Dict.get("state")->Option.flatMap(JSON.Decode.string),
+          key: obj->Dict.get("key")->Option.flatMap(JSON.Decode.string),
+          userId: obj->Dict.get("userId")->Option.flatMap(JSON.Decode.string)->Option.getOr(""),
+          endpoint: obj->Dict.get("endpoint")->Option.flatMap(JSON.Decode.string)->Option.getOr(""),
+          sendReadMessage: obj
+          ->Dict.get("sendReadMessage")
+          ->Option.flatMap(JSON.Decode.bool)
+          ->Option.getOr(false),
+        })
+      | None => Error("Invalid sw/register response")
+      }
+    | Error(e) => Error(e)
+    }
+  }
+
+  /// Unregister a push notification endpoint.
+  let unregister = async (client: t, ~endpoint: string): result<unit, string> => {
+    let params = Dict.make()
+    params->Dict.set("endpoint", endpoint->JSON.Encode.string)
+    switch await request(client, "sw/unregister", ~params=params->JSON.Encode.object, ()) {
+    | Ok(_) => Ok()
+    | Error(e) => Error(e)
+    }
+  }
+}
+
+// ============================================================================
+// Webhooks API
+// ============================================================================
+
+module Webhooks = {
+  type webhook = {
+    id: string,
+    name: string,
+    url: string,
+    active: bool,
+  }
+
+  /// Create a webhook on the Misskey instance.
+  let create = async (
+    client: t,
+    ~name: string,
+    ~url: string,
+    ~secret: string,
+    ~on: array<string>,
+    (),
+  ): result<webhook, string> => {
+    let params = Dict.make()
+    params->Dict.set("name", name->JSON.Encode.string)
+    params->Dict.set("url", url->JSON.Encode.string)
+    params->Dict.set("secret", secret->JSON.Encode.string)
+    params->Dict.set("on", on->Array.map(JSON.Encode.string)->JSON.Encode.array)
+    switch await request(client, "i/webhooks/create", ~params=params->JSON.Encode.object, ()) {
+    | Ok(json) =>
+      switch json->JSON.Decode.object {
+      | Some(obj) =>
+        let id = obj->Dict.get("id")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+        let name = obj->Dict.get("name")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+        let url = obj->Dict.get("url")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+        let active = obj->Dict.get("active")->Option.flatMap(JSON.Decode.bool)->Option.getOr(false)
+        Ok({id, name, url, active})
+      | None => Error("Invalid webhook response")
+      }
+    | Error(e) => Error(e)
+    }
+  }
+
+  /// Delete a webhook by ID.
+  let delete = async (client: t, ~webhookId: string): result<unit, string> => {
+    let params = Dict.make()
+    params->Dict.set("webhookId", webhookId->JSON.Encode.string)
+    switch await request(client, "i/webhooks/delete", ~params=params->JSON.Encode.object, ()) {
+    | Ok(_) => Ok()
+    | Error(e) => Error(e)
+    }
+  }
+
+  /// List webhooks for the current user.
+  let list = async (client: t): result<array<webhook>, string> => {
+    switch await request(client, "i/webhooks/list", ()) {
+    | Ok(json) =>
+      switch json->JSON.Decode.array {
+      | Some(arr) =>
+        Ok(arr->Array.filterMap(item => {
+          switch item->JSON.Decode.object {
+          | Some(obj) =>
+            let id = obj->Dict.get("id")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+            let name = obj->Dict.get("name")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+            let url = obj->Dict.get("url")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+            let active = obj->Dict.get("active")->Option.flatMap(JSON.Decode.bool)->Option.getOr(false)
+            Some({id, name, url, active})
+          | None => None
+          }
+        }))
+      | None => Ok([])
+      }
+    | Error(e) => Error(e)
+    }
+  }
+}
+
 let isAPIError = (error: JSON.t): option<apiError> => {
   switch error->JSON.Decode.object {
   | Some(obj) =>
@@ -675,4 +938,70 @@ let isAPIError = (error: JSON.t): option<apiError> => {
   }
 }
 
+// ============================================================================
+// Drive API
+// ============================================================================
+// NOTE: All HTTP calls in this module (and throughout Misskey.res) should use
+// `Ofetch.ofetch` rather than raw `fetch`.  ofetch handles JSON parsing,
+// non-2xx error throwing, and runtime FormData detection automatically, which
+// avoids the pitfall of calling `response.json()` on non-standard objects.
+
+module Drive = {
+  /// Upload a File object to the Misskey drive.
+  /// Returns the drive file ID on success.
+  let upload = async (client: t, ~file: {..}, ~sensitive: bool=false, ()): result<string, string> => {
+    try {
+      let fd: {..} = %raw(`new FormData()`)
+      fd["append"]("file", file)
+      client.token->Option.forEach(tok => fd["append"]("i", tok))
+      if sensitive { fd["append"]("isSensitive", "true") }
+
+      let endpoint = client.origin ++ "/api/drive/files/create"
+      // Cast FormData to JSON.t so ofetch can accept it;
+      // ofetch detects FormData at runtime and sends multipart/form-data correctly.
+      let json = await Ofetch.ofetch(endpoint, {
+        method: "POST",
+        body: fd->Obj.magic,
+      })
+
+      switch json->JSON.Decode.object->Option.flatMap(obj => obj->Dict.get("id")) {
+      | Some(idJson) =>
+        switch idJson->JSON.Decode.string {
+        | Some(id) => Ok(id)
+        | None => Error("Drive upload: id is not a string")
+        }
+      | None =>
+        let errDetail =
+          json
+          ->JSON.Decode.object
+          ->Option.flatMap(obj => obj->Dict.get("error"))
+          ->Option.flatMap(JSON.Decode.object)
+          ->Option.flatMap(obj => obj->Dict.get("message"))
+          ->Option.flatMap(JSON.Decode.string)
+        let statusCode =
+          json
+          ->JSON.Decode.object
+          ->Option.flatMap(obj => obj->Dict.get("error"))
+          ->Option.flatMap(JSON.Decode.object)
+          ->Option.flatMap(obj => obj->Dict.get("code"))
+          ->Option.flatMap(JSON.Decode.string)
+        let msg = switch (statusCode, errDetail) {
+        | (Some(code), Some(detail)) => code ++ ": " ++ detail
+        | (None, Some(detail)) => detail
+        | (Some(code), None) => "Upload error: " ++ code
+        | (None, None) => "Unknown upload error"
+        }
+        Error(msg)
+      }
+    } catch {
+    | err =>
+      let msg = switch err->JsExn.fromException {
+      | Some(jsExn) => JsExn.message(jsExn)->Option.getOr("Drive upload failed")
+      | None => "Drive upload failed"
+      }
+      Error(msg)
+    }
+  }
+}
+
 let default = connect