chore: Refactor Mastodon specific logic with hook API

src/adapters/action/dispatcher-http-hook-mastodon.spec.ts → src/adapters/action/dispatcher-http.spec.ts

@@ -1,9 +1,9 @@
 import { httpGet, HttpMockImpl, httpPost } from "../../__mocks__";
 import { MastoHttpError, MastoTimeoutError } from "../errors";
+import { ActionDispatcherHookMastodon } from "../hook/hook-action-dispatcher-mastodon";
 import { HttpActionDispatcher } from "./dispatcher-http";
-import { HttpActionDispatcherHookMastodon } from "./dispatcher-http-hook-mastodon";
 
-describe("DispatcherHttp", () => {
+describe("HttpActionDispatcher", () => {
   afterEach(() => {
     httpGet.mockClear();
     httpPost.mockClear();
@@ -13,7 +13,7 @@ describe("DispatcherHttp", () => {
     const http = new HttpMockImpl();
     const dispatcher = new HttpActionDispatcher(
       http,
-      new HttpActionDispatcherHookMastodon(http),
+      new ActionDispatcherHookMastodon(http),
     );
 
     httpPost.mockResolvedValueOnce({ id: "1" });
@@ -43,7 +43,7 @@ describe("DispatcherHttp", () => {
     const http = new HttpMockImpl();
     const dispatcher = new HttpActionDispatcher(
       http,
-      new HttpActionDispatcherHookMastodon(http, 1),
+      new ActionDispatcherHookMastodon(http, 1),
     );
 
     httpPost.mockResolvedValueOnce({ id: "1" });
@@ -65,7 +65,7 @@ describe("DispatcherHttp", () => {
     const http = new HttpMockImpl();
     const dispatcher = new HttpActionDispatcher(
       http,
-      new HttpActionDispatcherHookMastodon(http),
+      new ActionDispatcherHookMastodon(http),
     );
 
     httpPost.mockResolvedValueOnce({ id: "1" });
@@ -85,7 +85,7 @@ describe("DispatcherHttp", () => {
     const http = new HttpMockImpl();
     const dispatcher = new HttpActionDispatcher(
       http,
-      new HttpActionDispatcherHookMastodon(http),
+      new ActionDispatcherHookMastodon(http),
     );
 
     httpPost.mockResolvedValueOnce({ id: "1" });

src/adapters/action/dispatcher-http.ts

@@ -1,29 +1,23 @@
 import {
-  type Action,
   type ActionDispatcher,
   type ActionDispatcherHook,
+  type AnyAction,
   type Http,
 } from "../../interfaces";
 import { PaginatorHttp } from "./paginator-http";
 
-export type HttpActionType = "fetch" | "create" | "update" | "remove" | "list";
-export type HttpAction = Action<HttpActionType>;
-
-export class HttpActionDispatcher implements ActionDispatcher<HttpAction> {
+export class HttpActionDispatcher implements ActionDispatcher<AnyAction> {
   constructor(
     private readonly http: Http,
-    private readonly hook: ActionDispatcherHook<HttpAction>,
+    private readonly hook?: ActionDispatcherHook,
   ) {}
 
-  dispatch<T>(action: HttpAction): T | Promise<T> {
-    if (this.hook != undefined) {
-      action = this.hook.beforeDispatch(action);
+  dispatch<T>(action: AnyAction): T | Promise<T> {
+    if (this.hook) {
+      action = this.hook.before(action);
     }
 
-    let result = this.hook.dispatch(action) as T | Promise<T> | false;
-    if (result !== false) {
-      return result;
-    }
+    let result!: T | Promise<T>;
 
     switch (action.type) {
       case "fetch": {
@@ -48,12 +42,15 @@ export class HttpActionDispatcher implements ActionDispatcher<HttpAction> {
       }
     }
 
-    /* eslint-disable unicorn/prefer-ternary, prettier/prettier */
-    if (result instanceof Promise) {
-      return result.then((result) => this.hook?.afterDispatch(action, result)) as Promise<T>;
-    } else {
-      return this.hook.afterDispatch(action, result) as T;
+    if (this.hook) {
+      /* eslint-disable unicorn/prefer-ternary, prettier/prettier */
+      if (result instanceof Promise) {
+        return result.then((result) => this.hook?.after(result, action)) as Promise<T>;
+      } else {
+        return this.hook?.after(result, action) as T;
+      }
     }
-    /* eslint-enable unicorn/prefer-ternary, prettier/prettier */
+
+    return result;
   }
 }

src/adapters/clients.ts

@@ -1,17 +1,23 @@
-import { type LogType } from "../interfaces";
+import {
+  type ActionDispatcherHook,
+  combine,
+  type Hook,
+  type HttpHook,
+  type LogType,
+} from "../interfaces";
 import { type mastodon } from "../mastodon";
 import {
   createActionProxy,
   HttpActionDispatcher,
   WebSocketActionDispatcher,
 } from "./action";
-import { HttpActionDispatcherHookMastodon } from "./action/dispatcher-http-hook-mastodon";
 import {
   HttpConfigImpl,
   type MastoHttpConfigProps,
   WebSocketConfigImpl,
   type WebSocketConfigProps,
 } from "./config";
+import { ActionDispatcherHookMastodon, HttpHookMastodon } from "./hook";
 import { HttpNativeImpl } from "./http";
 import { createLogger } from "./logger";
 import { SerializerNativeImpl } from "./serializers";
@@ -31,15 +37,40 @@ interface LogConfigProps {
   readonly log?: LogType;
 }
 
+interface HookProps {
+  readonly use?: readonly Hook[];
+}
+
 export const createRestAPIClient = (
-  props: MastoHttpConfigProps & LogConfigProps,
+  props: MastoHttpConfigProps & LogConfigProps & HookProps,
 ): mastodon.rest.Client => {
+  const use = props.use ?? [];
+
   const serializer = new SerializerNativeImpl();
   const config = new HttpConfigImpl(props, serializer);
   const logger = createLogger(props.log);
-  const http = new HttpNativeImpl(serializer, config, logger);
-  const hook = new HttpActionDispatcherHookMastodon(http);
-  const actionDispatcher = new HttpActionDispatcher(http, hook);
+
+  const http = new HttpNativeImpl(
+    serializer,
+    config,
+    logger,
+    combine([
+      ...use.filter((hook): hook is HttpHook => hook.type === "Http"),
+      new HttpHookMastodon(),
+    ]),
+  );
+
+  const actionDispatcher = new HttpActionDispatcher(
+    http,
+    combine([
+      ...use.filter(
+        (hook): hook is ActionDispatcherHook =>
+          hook.type === "ActionDispatcher",
+      ),
+      new ActionDispatcherHookMastodon(http),
+    ]),
+  );
+
   const actionProxy = createActionProxy(actionDispatcher, {
     context: ["api"],
   }) as mastodon.rest.Client;
@@ -53,8 +84,8 @@ export const createOAuthAPIClient = (
   const config = new HttpConfigImpl(props, serializer);
   const logger = createLogger(props.log);
   const http = new HttpNativeImpl(serializer, config, logger);
-  const hook = new HttpActionDispatcherHookMastodon(http);
-  const actionDispatcher = new HttpActionDispatcher(http, hook);
+  const actionDispatcherHook = new ActionDispatcherHookMastodon(http);
+  const actionDispatcher = new HttpActionDispatcher(http, actionDispatcherHook);
   const actionProxy = createActionProxy(actionDispatcher, {
     context: ["oauth"],
   }) as mastodon.oauth.Client;

src/adapters/action/dispatcher-http-hook-mastodon.ts → src/adapters/hook/hook-action-dispatcher-mastodon.ts

@@ -10,7 +10,8 @@ import {
 import { type mastodon } from "../../mastodon";
 import { isRecord, sleep } from "../../utils";
 import { MastoHttpError, MastoTimeoutError } from "../errors";
-import { type HttpAction, type HttpActionType } from "./dispatcher-http";
+
+type HttpActionType = "fetch" | "create" | "update" | "remove" | "list";
 
 function isHttpActionType(actionType: string): actionType is HttpActionType {
   return ["fetch", "create", "update", "remove", "list"].includes(actionType);
@@ -84,15 +85,15 @@ async function waitForMediaAttachment(
   return media;
 }
 
-export class HttpActionDispatcherHookMastodon
-  implements ActionDispatcherHook<AnyAction>
-{
+export class ActionDispatcherHookMastodon implements ActionDispatcherHook {
+  readonly type = "ActionDispatcher";
+
   constructor(
     private readonly http: Http,
     private readonly mediaTimeout = 1000 * 60,
   ) {}
 
-  beforeDispatch(action: AnyAction): HttpAction {
+  before(action: AnyAction): AnyAction {
     const type = toHttpActionType(action.type);
     const path = isHttpActionType(action.type)
       ? action.path
@@ -103,18 +104,7 @@ export class HttpActionDispatcherHookMastodon
     return { type, path, data: action.data, meta };
   }
 
-  dispatch(action: AnyAction): false | Promise<unknown> {
-    if (
-      action.type === "update" &&
-      action.path === "/api/v1/accounts/update_credentials"
-    ) {
-      return this.http.patch(action.path, action.data, action.meta);
-    }
-
-    return false;
-  }
-
-  afterDispatch(action: AnyAction, result: unknown): unknown {
+  after(result: unknown, action: AnyAction): unknown {
     if (action.type === "create" && action.path === "/api/v2/media") {
       const media = result as mastodon.v1.MediaAttachment;
       if (isRecord(action.data) && action.data?.skipPolling === true) {

src/adapters/hook/hook-http-mastodon.spec.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert";
+
+import { HttpHookMastodon } from "./hook-http-mastodon";
+
+describe("hookHttpMastodon", () => {
+  it("returns a new Request with method PATCH if the request is PUT and the URL ends with /api/v1/accounts/update_credentials", async () => {
+    const request = new Request(
+      "https://example.com/api/v1/accounts/update_credentials",
+      { method: "PUT" },
+    );
+    const hook = new HttpHookMastodon();
+    const result = await hook.before(request);
+    assert(result instanceof Request);
+    expect(result).toBeInstanceOf(Request);
+    expect(result.method).toBe("PATCH");
+  });
+});

src/adapters/hook/hook-http-mastodon.ts

@@ -0,0 +1,19 @@
+import { type HttpHook } from "../../interfaces/hook";
+
+export class HttpHookMastodon implements HttpHook {
+  readonly type = "Http";
+
+  async before(request: Request): Promise<Request> {
+    if (
+      request.method === "PUT" &&
+      request.url.endsWith("/api/v1/accounts/update_credentials")
+    ) {
+      return new Request(request, { method: "PATCH" });
+    }
+    return request;
+  }
+
+  async after(response: Response): Promise<Response> {
+    return response;
+  }
+}

src/adapters/hook/index.ts

@@ -0,0 +1,2 @@
+export * from "./hook-action-dispatcher-mastodon";
+export * from "./hook-http-mastodon";

src/adapters/http/http-native-impl.ts

@@ -1,6 +1,7 @@
 import {
   type Http,
   type HttpConfig,
+  type HttpHook,
   type HttpRequestParams,
   type HttpRequestResult,
   type Logger,
@@ -20,20 +21,31 @@ export class HttpNativeImpl extends BaseHttp implements Http {
     private readonly serializer: Serializer,
     private readonly config: HttpConfig,
     private readonly logger?: Logger,
+    private readonly hook?: HttpHook,
   ) {
     super();
   }
 
   async request(params: HttpRequestParams): Promise<HttpRequestResult> {
-    const request = this.createRequest(params);
+    let request = this.createRequest(params);
+
+    if (this.hook) {
+      request = await this.hook.before(request);
+    }
+
+    this.logger?.log("info", `↑ ${request.method} ${request.url}`);
+    this.logger?.log("debug", "\tbody", {
+      encoding: params.encoding,
+      body: params.body,
+    });
 
     try {
-      this.logger?.log("info", `↑ ${request.method} ${request.url}`);
-      this.logger?.log("debug", "\tbody", {
-        encoding: params.encoding,
-        body: params.body,
-      });
-      const response = await fetch(request);
+      let response = await fetch(request);
+
+      if (this.hook) {
+        response = await this.hook.after(response);
+      }
+
       if (!response.ok) {
         throw response;
       }

src/interfaces/action.ts

@@ -15,8 +15,8 @@ export interface ActionDispatcher<T extends AnyAction> {
   [Symbol.dispose]?(): void;
 }
 
-export interface ActionDispatcherHook<T extends AnyAction, U = unknown> {
-  beforeDispatch(action: T): T;
-  dispatch(action: T): U | Promise<U> | false;
-  afterDispatch(action: T, result: U | Promise<U>): U;
-}
+// export interface ActionDispatcherHook<T extends AnyAction, U = unknown> {
+//   beforeDispatch(action: T): T;
+//   dispatch(action: T): U | Promise<U> | false;
+//   afterDispatch(action: T, result: U | Promise<U>): U;
+// }