wip

Author: neet

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

@@ -25,7 +25,10 @@ describe("DispatcherHttp", () => {
       .mockRejectedValueOnce(
         new MastoHttpError({ statusCode: 404, message: "Not Found" }),
       )
-      .mockResolvedValueOnce({ id: "1", url: "https://example.com" });
+      .mockResolvedValueOnce({
+        headers: new Headers(),
+        data: { id: "1", url: "https://example.com" },
+      });
 
     const media = await dispatcher.dispatch({
       type: "create",

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

@@ -66,7 +66,7 @@ async function waitForMediaAttachment(
     try {
       await sleep(1000);
 
-      const processing = await http.get<mastodon.v1.MediaAttachment>(
+      const { data: processing } = await http.get<mastodon.v1.MediaAttachment>(
         `/api/v1/media/${id}`,
       );
 

src/adapters/action/dispatcher-http.ts

@@ -3,24 +3,41 @@ import {
   type ActionDispatcher,
   type ActionDispatcherHook,
   type Http,
+  type HttpResponse,
 } from "../../interfaces/index.js";
+import { type Paginator } from "../../mastodon/paginator.js";
 import { PaginatorHttp } from "./paginator-http.js";
 
-export type HttpActionType = "fetch" | "create" | "update" | "remove" | "list";
+export type HttpActionMap = {
+  fetch: Promise<HttpResponse<unknown>>;
+  create: Promise<HttpResponse<unknown>>;
+  update: Promise<HttpResponse<unknown>>;
+  remove: Promise<HttpResponse<unknown>>;
+  list: Paginator<unknown>;
+};
+
+export type HttpActionType = keyof HttpActionMap;
 export type HttpAction = Action<HttpActionType>;
 
-export class HttpActionDispatcher implements ActionDispatcher<HttpAction> {
+export class HttpActionDispatcher implements ActionDispatcher<HttpActionMap> {
   constructor(
     private readonly http: Http,
     private readonly hook: ActionDispatcherHook<HttpAction>,
   ) {}
 
-  dispatch<T>(action: HttpAction): T | Promise<T> {
+  dispatch(
+    action: Action<"fetch" | "create" | "update" | "remove">,
+  ): Promise<HttpResponse<unknown>>;
+  dispatch(action: Action<"list">): Paginator<unknown>;
+  dispatch(action: Action<HttpActionType>): unknown {
     if (this.hook) {
       action = this.hook.beforeDispatch(action);
     }
 
-    let result = this.hook.dispatch(action) as T | Promise<T> | false;
+    let result = this.hook.dispatch(action) as
+      | Promise<HttpResponse<unknown>>
+      | Paginator<unknown>
+      | false;
     if (result !== false) {
       return result;
     }
@@ -43,16 +60,16 @@ export class HttpActionDispatcher implements ActionDispatcher<HttpAction> {
         break;
       }
       case "list": {
-        result = new PaginatorHttp(this.http, action.path, action.data) as T;
+        result = new PaginatorHttp(this.http, action.path, action.data);
         break;
       }
     }
 
     /* eslint-disable unicorn/prefer-ternary, prettier/prettier */
     if (result instanceof Promise) {
-      return result.then((result) => this.hook?.afterDispatch(action, result)) as Promise<T>;
+      return result.then((result) => this.hook?.afterDispatch(action, result)) as Promise<HttpResponse<unknown>>;
     } else {
-      return this.hook.afterDispatch(action, result) as T;
+      return this.hook.afterDispatch(action, result) as Paginator<unknown>;
     }
     /* eslint-enable unicorn/prefer-ternary, prettier/prettier */
   }

src/adapters/action/dispatcher-ws.ts

@@ -9,11 +9,17 @@ import {
 import { MastoUnexpectedError } from "../errors/index.js";
 import { WebSocketSubscription } from "../ws/index.js";
 
-type WebSocketActionType = "close" | "prepare" | "subscribe";
+type WebSocketActionMap = {
+  close: undefined;
+  prepare: Promise<WebSocket>;
+  subscribe: WebSocketSubscription;
+};
+
+type WebSocketActionType = keyof WebSocketActionMap;
 type WebSocketAction = Action<WebSocketActionType>;
 
 export class WebSocketActionDispatcher
-  implements ActionDispatcher<WebSocketAction>
+  implements ActionDispatcher<WebSocketActionMap>
 {
   constructor(
     private readonly connector: WebSocketConnector,
@@ -22,31 +28,34 @@ export class WebSocketActionDispatcher
     private readonly logger?: Logger,
   ) {}
 
-  dispatch<T>(action: WebSocketAction): T {
+  dispatch(action: Action<"close">): void;
+  dispatch(action: Action<"prepare">): Promise<WebSocket>;
+  dispatch(action: Action<"subscribe">): WebSocketSubscription;
+  dispatch(action: WebSocketAction): unknown {
     if (action.type === "close") {
       this.connector.kill();
-      return {} as T;
+      return;
     }
 
     if (action.type === "prepare") {
-      return this.connector.acquire() as T;
+      return this.connector.acquire();
     }
 
-    if (action.type !== "subscribe") {
-      throw new MastoUnexpectedError(`Unknown action type ${action.type}`);
+    if (action.type === "subscribe") {
+      const data = action.data ?? {};
+      const stream = action.path.replace(/^\//, "").replaceAll("/", ":");
+
+      return new WebSocketSubscription(
+        this.connector,
+        this.counter,
+        this.serializer,
+        stream,
+        this.logger,
+        { ...data },
+      );
     }
 
-    const data = action.data ?? {};
-    const stream = action.path.replace(/^\//, "").replaceAll("/", ":");
-
-    return new WebSocketSubscription(
-      this.connector,
-      this.counter,
-      this.serializer,
-      stream,
-      this.logger,
-      { ...data },
-    ) as T;
+    throw new MastoUnexpectedError(`Unknown action type ${action.type}`);
   }
 
   [Symbol.dispose](): void {

src/adapters/action/proxy.ts

@@ -2,9 +2,9 @@ import { snakeCase } from "change-case";
 
 import {
   type ActionDispatcher,
-  type AnyAction,
   type HttpMetaParams,
 } from "../../interfaces/index.js";
+import { isRecord } from "../../utils/is-record.js";
 import { noop } from "../../utils/noop.js";
 
 type CreateActionProxyOptions = {
@@ -13,7 +13,7 @@ type CreateActionProxyOptions = {
 };
 
 export const createActionProxy = <T>(
-  actionDispatcher: ActionDispatcher<AnyAction>,
+  actionDispatcher: ActionDispatcher,
   options: CreateActionProxyOptions = {},
 ): T => {
   const { context = [], applicable = false } = options;
@@ -52,10 +52,7 @@ const SPECIAL_PROPERTIES = new Set([
 ]);
 
 const get =
-  <T>(
-    actionDispatcher: ActionDispatcher<AnyAction>,
-    context: readonly string[],
-  ) =>
+  <T>(actionDispatcher: ActionDispatcher, context: readonly string[]) =>
   (_: unknown, property: string | symbol) => {
     if (typeof property === "string" && SPECIAL_PROPERTIES.has(property)) {
       return;
@@ -79,7 +76,7 @@ const get =
   };
 
 const apply =
-  <T>(actionDispatcher: ActionDispatcher<AnyAction>, context: string[]) =>
+  <T>(actionDispatcher: ActionDispatcher, context: string[]) =>
   (_1: unknown, _2: unknown, args: unknown[]): unknown => {
     const action = context.pop();
 
@@ -98,10 +95,16 @@ const apply =
     const path = "/" + context.join("/");
     const [data, meta] = args;
 
-    return actionDispatcher.dispatch<T>({
+    const result = actionDispatcher.dispatch({
       type: action,
       path,
       data,
       meta: meta as HttpMetaParams,
     });
+
+    if (action === "$raw") {
+      return result;
+    } else {
+      return isRecord(result) && "data" in result ? result.data : result;
+    }
   };

src/adapters/http/base-http.ts

@@ -3,74 +3,74 @@ import {
   type Http,
   type HttpMetaParams,
   type HttpRequestParams,
-  type HttpRequestResult,
+  type HttpResponse,
 } from "../../interfaces/index.js";
 
 export abstract class BaseHttp implements Http {
-  abstract request(params: HttpRequestParams): Promise<HttpRequestResult>;
+  abstract request<T>(params: HttpRequestParams): Promise<HttpResponse<T>>;
 
   get<T>(
     path: string,
     data?: unknown,
     meta: HttpMetaParams<Encoding> = {},
-  ): Promise<T> {
+  ): Promise<HttpResponse<T>> {
     return this.request({
       method: "GET",
       path,
       search: data as Record<string, unknown>,
       ...meta,
-    }).then((response) => response.data as T);
+    });
   }
 
   post<T>(
     path: string,
     data?: unknown,
     meta: HttpMetaParams<Encoding> = {},
-  ): Promise<T> {
+  ): Promise<HttpResponse<T>> {
     return this.request({
       method: "POST",
       path,
       body: data as Record<string, unknown>,
       ...meta,
-    }).then((response) => response.data as T);
+    });
   }
 
   delete<T>(
     path: string,
     data?: unknown,
     meta: HttpMetaParams<Encoding> = {},
-  ): Promise<T> {
+  ): Promise<HttpResponse<T>> {
     return this.request({
       method: "DELETE",
       path,
       body: data as Record<string, unknown>,
       ...meta,
-    }).then((response) => response.data as T);
+    });
   }
 
   put<T>(
     path: string,
     data?: unknown,
     meta: HttpMetaParams<Encoding> = {},
-  ): Promise<T> {
+  ): Promise<HttpResponse<T>> {
     return this.request({
       method: "PUT",
       path,
       body: data as Record<string, unknown>,
       ...meta,
-    }).then((response) => response.data as T);
+    });
   }
 
   patch<T>(
     path: string,
     data?: unknown,
     meta: HttpMetaParams<Encoding> = {},
-  ): Promise<T> {
+  ): Promise<HttpResponse<T>> {
     return this.request({
       method: "PATCH",
       path,
       body: data as Record<string, unknown>,
       ...meta,
-    }).then((response) => response.data as T);
+    });
   }
 }

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

@@ -2,7 +2,7 @@ import {
   type Http,
   type HttpConfig,
   type HttpRequestParams,
-  type HttpRequestResult,
+  type HttpResponse,
   type Logger,
   type Serializer,
 } from "../../interfaces/index.js";
@@ -24,7 +24,7 @@ export class HttpNativeImpl extends BaseHttp implements Http {
     super();
   }
 
-  async request(params: HttpRequestParams): Promise<HttpRequestResult> {
+  async request<T>(params: HttpRequestParams): Promise<HttpResponse<T>> {
     const request = this.createRequest(params);
 
     try {
@@ -52,7 +52,7 @@ export class HttpNativeImpl extends BaseHttp implements Http {
 
       return {
         headers: response.headers,
-        data,
+        data: data as T,
       };
     } catch (error) {
       this.logger?.log("debug", `HTTP failed`, error);

src/interfaces/action.ts

@@ -1,7 +1,7 @@
 import { type HttpMetaParams } from "./http.js";
 import { type Encoding } from "./serializer.js";
 
-export interface Action<T extends string> {
+export interface Action<T> {
   readonly type: T;
   readonly path: string;
   readonly data: unknown;
@@ -10,8 +10,10 @@ export interface Action<T extends string> {
 
 export type AnyAction = Action<string>;
 
-export interface ActionDispatcher<T extends AnyAction> {
-  dispatch<U>(action: T): U | Promise<U>;
+export type ActionMap = { [key in string]: unknown };
+
+export interface ActionDispatcher<U extends ActionMap = ActionMap> {
+  dispatch<T extends keyof U>(action: Action<T>): U[T];
   [Symbol.dispose]?(): void;
 }
 

src/interfaces/http.ts

@@ -12,19 +12,19 @@ export type HttpRequestParams = HttpMetaParams<Encoding> & {
   readonly body?: Record<string, unknown>;
 };
 
-export interface HttpRequestResult {
+export interface HttpResponse<T = unknown> {
   headers: Headers;
-  data: unknown;
+  data: T;
 }
 
 export type HttpMethod = <T>(
   path: string,
   data?: unknown,
   meta?: HttpMetaParams<Encoding>,
-) => Promise<T>;
+) => Promise<HttpResponse<T>>;
 
 export interface Http {
-  readonly request: (params: HttpRequestParams) => Promise<HttpRequestResult>;
+  readonly request: <T>(params: HttpRequestParams) => Promise<HttpResponse<T>>;
   readonly get: HttpMethod;
   readonly post: HttpMethod;
   readonly patch: HttpMethod;

src/mastodon/endpoint.ts

@@ -0,0 +1,22 @@
+type OptionalRecord = {
+  [key in string]?: unknown;
+};
+
+type RawResponse = {
+  data: Response;
+  headers: Headers;
+};
+
+export type Endpoint<Params, Meta, Response> = Params extends
+  | OptionalRecord
+  | undefined
+  ? {
+      (params?: Params, meta?: Meta): Promise<Response>;
+      /** @experimental */
+      $raw(params?: Params, meta?: Meta): Promise<RawResponse>;
+    }
+  : {
+      (params: Params, meta?: Meta): Promise<Response>;
+      /** @experimental */
+      $raw(params: Params, meta?: Meta): Promise<RawResponse>;
+    };