akanjs 0.0.1 → 2.0.0-beta.0

package/fetch/client/httpClient.ts

@@ -0,0 +1,157 @@
+import type { SerializedArg } from "akanjs/signal";
+
+export interface ErrorResponsePayload {
+  error: string;
+  statusCode?: number;
+  data?: Record<string, unknown>;
+  details?: unknown;
+  path?: string;
+  timestamp?: string;
+}
+
+export interface RestoredError extends Error {
+  error?: string;
+  statusCode?: number;
+  data?: unknown;
+  details?: unknown;
+  path?: string;
+  timestamp?: string;
+}
+
+export interface ErrorConstructor {
+  fromJSON: (payload: ErrorResponsePayload) => RestoredError;
+}
+
+interface FetchOptions {
+  headers?: Record<string, string>;
+}
+
+export class HttpClient {
+  readonly baseUrl: string;
+  constructor(
+    baseUrl: string,
+    private ErrorCls?: ErrorConstructor,
+  ) {
+    this.baseUrl = baseUrl;
+  }
+
+  setErrorConstructor(ErrorCls?: ErrorConstructor) {
+    this.ErrorCls = ErrorCls;
+  }
+  async get<Returns = unknown>(url: string, options: FetchOptions = {}): Promise<Returns> {
+    const res = await fetch(`${this.baseUrl}${url}`, {
+      headers: { "Content-Type": "application/json", ...options.headers },
+    });
+    return await this.#readJsonResponse<Returns>(res);
+  }
+  #makeReqContent(data: FormData | Record<string, unknown>): { body: BodyInit; headers: Record<string, string> } {
+
+    if (data instanceof FormData) return { body: data, headers: {} };
+    return { body: JSON.stringify(data), headers: { "Content-Type": "application/json" } };
+  }
+  async put<Returns = unknown>(
+    url: string,
+    data: FormData | Record<string, unknown>,
+    options: FetchOptions = {},
+  ): Promise<Returns> {
+    const { body, headers } = this.#makeReqContent(data);
+    const res = await fetch(`${this.baseUrl}${url}`, {
+      method: "PUT",
+      body,
+      headers: { ...headers, ...options.headers },
+    });
+    return await this.#readJsonResponse<Returns>(res);
+  }
+  async post<Returns = unknown>(
+    url: string,
+    data: FormData | Record<string, unknown>,
+    options: FetchOptions = {},
+  ): Promise<Returns> {
+    const { body, headers } = this.#makeReqContent(data);
+    const res = await fetch(`${this.baseUrl}${url}`, {
+      method: "POST",
+      body,
+      headers: { ...headers, ...options.headers },
+    });
+    return await this.#readJsonResponse<Returns>(res);
+  }
+  async delete<Returns = unknown>(url: string, options: FetchOptions = {}): Promise<Returns> {
+    const res = await fetch(`${this.baseUrl}${url}`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json", ...options.headers },
+    });
+    return await this.#readJsonResponse<Returns>(res);
+  }
+
+  async #readJsonResponse<Returns>(res: Response): Promise<Returns> {
+    const body = await res.json();
+    if (res.ok) return body as Returns;
+    throw this.#restoreError(body, res.status);
+  }
+
+  #restoreError(body: unknown, fallbackStatusCode: number): RestoredError {
+    const payload =
+      body && typeof body === "object" && "error" in body
+        ? ({ statusCode: fallbackStatusCode, ...(body as Record<string, unknown>) } as ErrorResponsePayload)
+        : ({ error: String(body), statusCode: fallbackStatusCode } satisfies ErrorResponsePayload);
+    if (this.ErrorCls) return this.ErrorCls.fromJSON(payload);
+    const error = new Error(payload.error);
+    Object.assign(error, payload);
+    return error;
+  }
+  static makePath(key: string, paramArgs: SerializedArg[], prefix?: string) {
+    const paramPath = paramArgs.length > 0 ? `/${paramArgs.map((arg) => `:${arg.name}`).join("/")}` : "";
+    return `${prefix ? `/${prefix}` : ""}/${key}${paramPath}`;
+  }
+  static makeUrl(path: string, searchArgs: SerializedArg[], argMap: Map<string, unknown>) {
+    const searchParams = new URLSearchParams();
+    searchArgs.forEach((arg) => {
+      const argValue = argMap.get(arg.name);
+      if (argValue === null || argValue === undefined) return;
+      if (arg.arrDepth && Array.isArray(argValue))
+        argValue.forEach((value) => {
+          searchParams.append(arg.name, String(value));
+        });
+      else searchParams.set(arg.name, String(argValue));
+    });
+    const searchPath = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
+    const paramedPath = path.replace(/:(\w+)/g, (match, p1) => {
+      const value = argMap.get(p1);
+      return value === null || value === undefined ? match : String(value);
+    });
+    return `${paramedPath}${searchPath}`;
+  }
+  static makeBody(bodyArgs: SerializedArg[], uploadArgs: SerializedArg[], argMap: Map<string, unknown>) {
+    if (uploadArgs.length > 0) {
+      const formData = new FormData();
+      uploadArgs.forEach((arg) => {
+        const argValue = argMap.get(arg.name);
+        if (arg.nullable && (argValue === null || argValue === undefined)) return;
+        if (!arg.nullable && (argValue === null || argValue === undefined))
+          throw new Error(`Argument ${arg.name} is required`);
+        if (Array.isArray(argValue)) {
+          argValue.forEach((value) => {
+            formData.append(arg.name, value as Blob | string);
+          });
+        } else formData.append(arg.name, argValue as Blob | string);
+      });
+      bodyArgs.forEach((arg) => {
+        const argValue = argMap.get(arg.name);
+        if (arg.nullable && (argValue === null || argValue === undefined)) return;
+        if (!arg.nullable && (argValue === null || argValue === undefined))
+          throw new Error(`Argument ${arg.name} is required`);
+        formData.append(arg.name, typeof argValue === "string" ? argValue : JSON.stringify(argValue));
+      });
+      return formData;
+    } else {
+      const body: Record<string, unknown> = {};
+      bodyArgs.forEach((arg) => {
+        const argValue = argMap.get(arg.name);
+        if (!arg.nullable && (argValue === null || argValue === undefined))
+          throw new Error(`Argument ${arg.name} is required`);
+        body[arg.name] = argValue;
+      });
+      return body;
+    }
+  }
+}

package/fetch/client/index.ts

@@ -0,0 +1,3 @@
+export * from "./fetchClient";
+export * from "./httpClient";
+export * from "./wsClient";

package/fetch/client/wsClient.ts

@@ -0,0 +1,246 @@
+import { Logger } from "akanjs/common";
+import type {
+  WebsocketMessageData,
+  WebsocketPublishData,
+  WebsocketReqData,
+  WebsocketResData,
+  WebsocketSubscribeAck,
+} from "akanjs/signal";
+import type { ErrorConstructor, ErrorResponsePayload, RestoredError } from "./httpClient";
+
+export interface WsClientReconnectOptions {
+  enabled?: boolean;
+  interval?: number;
+  maxAttempts?: number;
+}
+
+interface SubscribeOption {
+  key: string;
+  data: unknown[];
+  listener: Set<(data: unknown) => void>;
+}
+interface Listener {
+  callback: (data: unknown) => void;
+  once: boolean;
+}
+
+type WsRequestPayload = unknown | unknown[];
+
+export class WsClient {
+  static makeRoomId(key: string, args: unknown[]) {
+    return `${key}${args.length ? "-" : ""}${args.join("-")}`;
+  }
+
+  readonly logger = new Logger("WsClient");
+  readonly url: string;
+  #ws: WebSocket | null = null;
+  #reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  #reconnectAttempts = 0;
+  #roomSubscribeMap = new Map<string, SubscribeOption>();
+  #listenerMap = new Map<string, Set<Listener>>();
+  #destroyed = false;
+  connected = false;
+
+  constructor(
+    url: string,
+    private ErrorCls?: ErrorConstructor,
+  ) {
+    this.url = url;
+  }
+
+  setErrorConstructor(ErrorCls?: ErrorConstructor) {
+    this.ErrorCls = ErrorCls;
+  }
+
+  connect() {
+    this.logger.debug(`Connecting to ${this.url}`);
+    this.#destroyed = false;
+    this.#reconnectAttempts = 0;
+    this.#connect();
+  }
+
+  #connect() {
+    if (this.#destroyed) return;
+
+    this.#ws = new WebSocket(this.url);
+    this.#ws.onopen = (e) => {
+      this.#reconnectAttempts = 0;
+      this.connected = true;
+      this.logger.debug(`WebSocket connected`);
+      this.#roomSubscribeMap.forEach((option) => {
+        const data: WebsocketReqData = { key: option.key, data: option.data, subscribe: true };
+        this.#ws?.send(JSON.stringify(data));
+      });
+    };
+    this.#ws.onmessage = (e) => {
+      try {
+        const parsed = typeof e.data === "string" ? JSON.parse(e.data) : e.data;
+        if (parsed?.error) {
+          throw this.#restoreError(parsed);
+        }
+        const type = (parsed as WebsocketResData).type;
+        switch (type) {
+          case "msg": {
+            const msg = parsed as unknown as WebsocketMessageData;
+            this.#handleMessage(msg.key, msg.data);
+            break;
+          }
+          case "sub": {
+            const sub = parsed as unknown as WebsocketSubscribeAck;
+            if (sub.subscribe) this.logger.verbose(`Websocket subscribe accepted: ${sub.roomId}`);
+            else this.logger.verbose(`Websocket unsubscribe accepted: ${sub.roomId}`);
+            break;
+          }
+          case "pub": {
+            const publishData = parsed as WebsocketPublishData;
+            this.#handlePubsub(publishData.roomId, publishData.data);
+            break;
+          }
+          default:
+            this.logger.warn(`Unknown WebSocket message type: ${type} ${JSON.stringify(parsed)}`);
+            break;
+        }
+      } catch (error) {
+        this.logger.warn("WebSocket message process failed");
+        console.error(error);
+      }
+    };
+    this.#ws.onerror = (e) => {
+      this.logger.debug(`WebSocket error`);
+      console.error(e);
+    };
+    this.#ws.onclose = (event) => {
+      this.logger.debug(`WebSocket closed: ${event.code} ${event.reason}`);
+      this.connected = false;
+      this.#scheduleReconnect();
+    };
+  }
+
+  #scheduleReconnect() {
+    if (this.#destroyed || !this.#ws) return;
+    const interval = 3000;
+    this.#reconnectAttempts += 1;
+    this.logger.debug(`WebSocket reconnecting in ${interval}ms (attempt ${this.#reconnectAttempts})`);
+
+    this.#ws = null;
+    this.#reconnectTimer = setTimeout(() => {
+      this.#reconnectTimer = null;
+      this.#connect();
+    }, interval);
+  }
+  #handleMessage(key: string, data: unknown) {
+    const listenerSet = this.#listenerMap.get(key);
+    if (!listenerSet?.size) return;
+    for (const listener of listenerSet) {
+      listener.callback(data);
+      if (listener.once) {
+        listenerSet.delete(listener);
+        if (listenerSet.size === 0) this.#listenerMap.delete(key);
+      }
+    }
+  }
+  #handlePubsub(roomId: string, data: unknown) {
+    const roomSubscribe = this.#roomSubscribeMap.get(roomId);
+    if (!roomSubscribe) return;
+    for (const listener of roomSubscribe.listener) listener(data);
+  }
+
+  #restoreError(body: unknown): RestoredError {
+    const payload =
+      body && typeof body === "object" && "error" in body
+        ? (body as ErrorResponsePayload)
+        : ({ error: String(body), statusCode: 500 } satisfies ErrorResponsePayload);
+    if (this.ErrorCls) return this.ErrorCls.fromJSON(payload);
+    const error = new Error(payload.error);
+    Object.assign(error, payload);
+    return error;
+  }
+
+  destroy() {
+    this.logger.debug(`WebSocket destroying`);
+    this.#destroyed = true;
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+    }
+    this.#ws?.close();
+    this.#ws = null;
+  }
+
+  on<Data = unknown>(key: string, callback: (data: Data) => void) {
+    const listenerSet = this.#listenerMap.get(key) ?? new Set<Listener>();
+    listenerSet.add({ callback: callback as (data: unknown) => void, once: false });
+    this.#listenerMap.set(key, listenerSet);
+    return this;
+  }
+  once<Data = unknown>(key: string, callback: (data: Data) => void) {
+    const listenerSet = this.#listenerMap.get(key) ?? new Set<Listener>();
+    listenerSet.add({ callback: callback as (data: unknown) => void, once: true });
+    this.#listenerMap.set(key, listenerSet);
+    return this;
+  }
+  off<Data = unknown>(key: string, callback: (data: Data) => void) {
+    const listenerSet = this.#listenerMap.get(key);
+    if (!listenerSet) return this;
+    for (const listener of listenerSet) {
+      if (listener.callback === callback) {
+        listenerSet.delete(listener);
+        break;
+      }
+    }
+    if (listenerSet.size === 0) this.#listenerMap.delete(key);
+    return this;
+  }
+  removeAllListeners(key: string) {
+    this.#listenerMap.delete(key);
+    return this;
+  }
+  hasListeners(key: string) {
+    const hasGeneric = (this.#listenerMap.get(key)?.size ?? 0) > 0;
+    const roomSub = this.#roomSubscribeMap.get(key);
+    const hasRoom = roomSub ? roomSub.listener.size > 0 : false;
+    return hasGeneric || hasRoom;
+  }
+  emit(key: string, data: WsRequestPayload) {
+    if (this.#ws?.readyState !== WebSocket.OPEN) {
+      this.logger.warn("WebSocket not connected");
+      return this;
+    }
+    const payload: WebsocketReqData = { key, data: Array.isArray(data) ? data : [data] };
+    this.#ws.send(JSON.stringify(payload));
+    return this;
+  }
+  subscribe(option: { key: string; data: unknown[]; handleEvent: (data: unknown) => void }) {
+    const roomId = WsClient.makeRoomId(option.key, option.data);
+    if (!this.#roomSubscribeMap.has(roomId)) {
+      this.#roomSubscribeMap.set(roomId, { key: option.key, data: option.data, listener: new Set() });
+      if (this.#ws?.readyState === WebSocket.OPEN) {
+        this.#sendSubscribe(option.key, option.data, true);
+      }
+      this.logger.verbose(`Websocket subscribe pubsub for ${roomId}`);
+    }
+    const roomSubscribe = this.#roomSubscribeMap.get(roomId);
+    if (!roomSubscribe) return;
+    roomSubscribe.listener.add(option.handleEvent);
+    this.logger.verbose(`Websocket subscribe pubsub for ${roomId} - ${roomSubscribe.listener.size} listeners added`);
+    return this;
+  }
+  unsubscribe(option: { key: string; data: unknown[]; handleEvent: (data: unknown) => void }) {
+    const roomId = WsClient.makeRoomId(option.key, option.data);
+    const roomSusbscribe = this.#roomSubscribeMap.get(roomId);
+    if (!roomSusbscribe) return;
+    roomSusbscribe.listener.delete(option.handleEvent);
+    this.logger.verbose(`Unsubscribe pubsub for ${roomId} - ${roomSusbscribe.listener.size} listeners remaining`);
+    if (roomSusbscribe.listener.size === 0) {
+      if (this.#ws?.readyState === WebSocket.OPEN) {
+        this.#sendSubscribe(option.key, option.data, false);
+      }
+      this.#roomSubscribeMap.delete(roomId);
+      this.logger.verbose(`Websocket unsubscribe for ${roomId}`);
+    }
+  }
+  #sendSubscribe(key: string, data: unknown[], subscribe: boolean) {
+    const payload: WebsocketReqData = { key, data, subscribe };
+    this.#ws?.send(JSON.stringify(payload));
+  }
+}

package/fetch/fetchType/appliedReturn.type.ts

@@ -0,0 +1,108 @@
+import type { DataList, GetStateObject, PromiseOrObject } from "akanjs/base";
+import type { ExtractSort, FilterInstance } from "akanjs/document";
+
+/** Metadata that identifies a generated slice list/insight request. */
+export type SliceMeta = {
+  refName: string;
+  sliceName: string;
+  argLength: number;
+};
+
+export type ServerInit<
+  RefName extends string,
+  Light,
+  Insight = any,
+  QueryArgs = any,
+  Filter extends FilterInstance = any,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _LightObj = GetStateObject<Light>,
+  _InsightObj = GetStateObject<Insight>,
+  _Sort = ExtractSort<Filter>,
+> = SliceMeta & {
+  [K in `${RefName}ObjList`]: _LightObj[];
+} & {
+  [K in `${RefName}ObjInsight`]: _InsightObj;
+} & {
+  [K in `pageOf${_CapitalizedRefName}`]: number;
+} & {
+  [K in `lastPageOf${_CapitalizedRefName}`]: number;
+} & {
+  [K in `limitOf${_CapitalizedRefName}`]: number;
+} & {
+  [K in `queryArgsOf${_CapitalizedRefName}`]: QueryArgs;
+} & {
+  [K in `sortOf${_CapitalizedRefName}`]: _Sort;
+} & {
+  [K in `${RefName}InitAt`]: Date;
+};
+/** Client/server-friendly return type for initialized list and insight data. */
+export type ClientInit<
+  RefName extends string,
+  Light,
+  Insight = any,
+  QueryArgs = any,
+  Filter extends FilterInstance = any,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _LightObj = GetStateObject<Light>,
+  _InsightObj = GetStateObject<Insight>,
+  _Sort = ExtractSort<Filter>,
+> = PromiseOrObject<
+  ServerInit<RefName, Light, Insight, QueryArgs, Filter, _CapitalizedRefName, _LightObj, _InsightObj, _Sort>
+>;
+
+export type ServerView<RefName extends string, Model> = { refName: RefName } & {
+  [K in `${RefName}Obj`]: GetStateObject<Model>;
+} & {
+  [K in `${RefName}ViewAt`]: Date;
+};
+/** Client/server-friendly return type for a single model view payload. */
+export type ClientView<RefName extends string, Model> = PromiseOrObject<ServerView<RefName, Model>>;
+
+export type ServerEdit<RefName extends string, Model> = { refName: RefName } & {
+  [K in `${RefName}Obj`]: GetStateObject<Model>;
+} & {
+  [K in `${RefName}ViewAt`]: Date;
+};
+export type ClientEdit<RefName extends string, Model> = PromiseOrObject<ServerEdit<RefName, Model>>;
+
+export type ViewReturn<RefName extends string, Full> = {
+  [K in RefName]: Full;
+} & {
+  [K in `${RefName}View`]: ServerView<RefName, Full>;
+};
+
+export type EditReturn<RefName extends string, Full> = {
+  [K in RefName]: Full;
+} & {
+  [K in `${RefName}Edit`]: ServerEdit<RefName, Full>;
+};
+
+export type InitReturn<
+  RefName extends string,
+  Suffix extends string,
+  Light,
+  Insight,
+  Args,
+  Filter extends FilterInstance,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _CapitalizedSuffix extends string = Capitalize<Suffix>,
+  _Light extends { id: string } = Light extends { id: string } ? Light : { id: string },
+  _LightObj = GetStateObject<_Light>,
+  _InsightObj = GetStateObject<Insight>,
+  _Sort = ExtractSort<Filter>,
+> = {
+  [K in `${RefName}Init${_CapitalizedSuffix}`]: ServerInit<
+    RefName,
+    Light,
+    Insight,
+    Args,
+    Filter,
+    _CapitalizedRefName,
+    _LightObj,
+    _InsightObj,
+    _Sort
+  >;
+} & {
+  [K in `${RefName}List${_CapitalizedSuffix}`]: DataList<_Light>;
+} & { [K in `${RefName}Insight${_CapitalizedSuffix}`]: Insight };
+

package/fetch/fetchType/buildFetch.type.ts

@@ -0,0 +1,24 @@
+import type { Assign } from "akanjs/base";
+import type { DatabaseSignal, ServiceSignal } from "akanjs/signal";
+import type { FetchProxy } from "../client";
+import type { GetFetchTypeFromEndpoint } from "./endpointFetch.type";
+import type { GetFetchTypeFromSlice } from "./sliceFetch.type";
+
+type GetFetchType<Signal extends FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>> =
+  Signal extends FetchProxy<infer FetchType>
+    ? FetchType
+    : Signal extends DatabaseSignal<any, infer EndpCls, infer SlceCls, any>
+      ? GetFetchTypeFromEndpoint<EndpCls> & GetFetchTypeFromSlice<SlceCls>
+      : Signal extends ServiceSignal<any, infer EndpCls, any>
+        ? GetFetchTypeFromEndpoint<EndpCls>
+        : unknown;
+
+export type MergeAllFetchTypes<
+  Signals extends (FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>)[],
+  Acc = unknown,
+> = Signals extends [
+  infer First extends FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>,
+  ...infer Rest extends (FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>)[],
+]
+  ? MergeAllFetchTypes<Rest, Assign<Acc, GetFetchType<First>>>
+  : Acc;

package/fetch/fetchType/clientSignal.type.ts

@@ -0,0 +1,22 @@
+import type { ConstantModel } from "akanjs/constant";
+import type { SerializedSignal, SerializedSlice, SliceCls } from "akanjs/signal";
+import type { FetchProxy } from "../client";
+
+export type ClientSlice = {
+  refName: string;
+  sliceName: string;
+  serializedSlice: SerializedSlice;
+};
+
+export type ClientSignal<
+  RefName extends string = string,
+  SlceCls extends SliceCls = SliceCls,
+  Cnst extends ConstantModel = ConstantModel,
+> = {
+  refName: RefName;
+  _slice: SlceCls;
+  cnst: Cnst;
+  fetch: FetchProxy<any>;
+  slices: ClientSlice[];
+  serializedSignal: SerializedSignal;
+};

package/fetch/fetchType/endpointFetch.type.ts

@@ -0,0 +1,56 @@
+import type { ENDPOINT_META, PromiseOrObject } from "akanjs/base";
+import type { FetchPolicy } from "akanjs/common";
+import type { EndpointCls, EndpointInfo } from "akanjs/signal";
+
+type EndpInfoType<E> = E extends EndpointInfo<infer T, any, any, any, any, any, any, any, any, any> ? T : never;
+type EndpInfoArgs<E> = E extends EndpointInfo<any, any, any, infer A, any, any, any, any, any, any> ? A : never;
+type EndpInfoReturns<E> =
+  E extends EndpointInfo<any, any, any, any, any, any, any, infer R, any, infer N>
+    ? R | (N extends true ? null : never)
+    : never;
+
+type QueryOrMutationFetchFn<E> = (
+  ...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]
+) => Promise<EndpInfoReturns<E>>;
+
+type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => EndpInfoReturns<E>;
+
+type MessageListenFn<E> = (
+  handleEvent: (data: EndpInfoReturns<E>) => PromiseOrObject<void>,
+  options?: FetchPolicy,
+) => () => void;
+
+type PubsubSubscribeFn<E> = (
+  ...args: [...EndpInfoArgs<E>, handleEvent: (data: EndpInfoReturns<E>) => PromiseOrObject<void>, options?: FetchPolicy]
+) => () => void;
+
+type PrimaryFetchType<EInfoObj extends { [key: string]: EndpointInfo }> = {
+  [K in keyof EInfoObj as EndpInfoType<EInfoObj[K]> extends "query" | "mutation" | "message" ? K : never]: EndpInfoType<
+    EInfoObj[K]
+  > extends "query" | "mutation"
+    ? QueryOrMutationFetchFn<EInfoObj[K]>
+    : EndpInfoType<EInfoObj[K]> extends "message"
+      ? MessageEmitFn<EInfoObj[K]>
+      : never;
+};
+
+type PubsubFetchType<EInfoObj extends { [key: string]: EndpointInfo }> = {
+  [K in keyof EInfoObj as EndpInfoType<EInfoObj[K]> extends "pubsub"
+    ? K extends string
+      ? `subscribe${Capitalize<K>}`
+      : never
+    : never]: PubsubSubscribeFn<EInfoObj[K]>;
+};
+
+type MessageListenFetchType<EInfoObj extends { [key: string]: EndpointInfo }> = {
+  [K in keyof EInfoObj as EndpInfoType<EInfoObj[K]> extends "message"
+    ? K extends string
+      ? `listen${Capitalize<K>}`
+      : never
+    : never]: MessageListenFn<EInfoObj[K]>;
+};
+
+export type GetFetchTypeFromEndpoint<
+  EndpCls extends EndpointCls,
+  _EndpointInfoObj extends { [key: string]: EndpointInfo } = EndpCls[typeof ENDPOINT_META],
+> = PrimaryFetchType<_EndpointInfoObj> & PubsubFetchType<_EndpointInfoObj> & MessageListenFetchType<_EndpointInfoObj>;

package/fetch/fetchType/index.ts

@@ -0,0 +1,5 @@
+export * from "./appliedReturn.type";
+export * from "./buildFetch.type";
+export * from "./clientSignal.type";
+export * from "./endpointFetch.type";
+export * from "./sliceFetch.type";