@lobehub/lobehub 2.0.0-next.225 → 2.0.0-next.226

package/src/services/marketApi.ts

@@ -1,6 +1,10 @@
-import { type AgentItemDetail, type AgentListResponse } from '@lobehub/market-sdk';
+import {
+  type AgentCreateResponse,
+  type AgentItemDetail,
+  type AgentListResponse,
+} from '@lobehub/market-sdk';
 
-import { MARKET_ENDPOINTS } from '@/services/_url';
+import { lambdaClient } from '@/libs/trpc/client';
 
 interface GetOwnAgentsParams {
   page?: number;
@@ -8,49 +12,15 @@ interface GetOwnAgentsParams {
 }
 
 export class MarketApiService {
-  private accessToken?: string;
-
-  // eslint-disable-next-line no-undef
-  private async request<T>(endpoint: string, init?: RequestInit): Promise<T> {
-    const headers = new Headers(init?.headers);
-
-    if (init?.body && !headers.has('content-type')) {
-      headers.set('content-type', 'application/json');
-    }
-
-    if (this.accessToken && !headers.has('authorization')) {
-      headers.set('authorization', `Bearer ${this.accessToken}`);
-    }
-
-    const response = await fetch(endpoint, {
-      ...init,
-      credentials: init?.credentials ?? 'same-origin',
-      headers,
-    });
-
-    if (!response.ok) {
-      let message = 'Unknown error';
-
-      try {
-        const errorBody = await response.json();
-        message = errorBody?.message ?? message;
-      } catch {
-        message = await response.text();
-      }
-
-      throw new Error(message || 'Market request failed');
-    }
-
-    if (response.status === 204) {
-      return undefined as T;
-    }
-
-    return (await response.json()) as T;
+  /**
+   * @deprecated This method is no longer needed as authentication is now handled
+   * automatically through tRPC middleware. Keeping for backward compatibility.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setAccessToken(_token: string) {
+    // No-op: Authentication is now handled through tRPC authedProcedure middleware
   }
 
-  setAccessToken(token: string) {
-    this.accessToken = token;
-  }
   // Create new agent
   async createAgent(agentData: {
     homepage?: string;
@@ -60,18 +30,15 @@ export class MarketApiService {
     status?: 'published' | 'unpublished' | 'archived' | 'deprecated';
     tokenUsage?: number;
     visibility?: 'public' | 'private' | 'internal';
-  }): Promise<AgentItemDetail> {
-    return this.request(MARKET_ENDPOINTS.createAgent, {
-      body: JSON.stringify(agentData),
-      method: 'POST',
-    });
+  }): Promise<AgentCreateResponse> {
+    return lambdaClient.market.agent.createAgent.mutate(agentData);
   }
 
   // Get agent detail by identifier
   async getAgentDetail(identifier: string): Promise<AgentItemDetail> {
-    return this.request(MARKET_ENDPOINTS.getAgentDetail(identifier), {
-      method: 'GET',
-    });
+    return lambdaClient.market.agent.getAgentDetail.query({
+      identifier,
+    }) as Promise<AgentItemDetail>;
   }
 
   // Check if agent exists (returns true if exists, false if not)
@@ -111,55 +78,28 @@ export class MarketApiService {
     supportsAuthenticatedExtendedCard?: boolean;
     tokenUsage?: number;
     url?: string;
-  }): Promise<AgentItemDetail> {
-    const { identifier, ...rest } = versionData;
-    const targetIdentifier = identifier;
-    if (!targetIdentifier) throw new Error('Identifier is required');
-
-    return this.request(MARKET_ENDPOINTS.createAgentVersion, {
-      body: JSON.stringify({
-        identifier: targetIdentifier,
-        ...rest,
-      }),
-      method: 'POST',
-    });
+  }) {
+    return lambdaClient.market.agent.createAgentVersion.mutate(versionData);
   }
 
   // Publish agent (make it visible in marketplace)
   async publishAgent(identifier: string): Promise<void> {
-    return this.request(MARKET_ENDPOINTS.publishAgent(identifier), {
-      method: 'POST',
-    });
+    await lambdaClient.market.agent.publishAgent.mutate({ identifier });
   }
 
   // Unpublish agent (hide from marketplace, can be republished)
   async unpublishAgent(identifier: string): Promise<void> {
-    return this.request(MARKET_ENDPOINTS.unpublishAgent(identifier), {
-      method: 'POST',
-    });
+    await lambdaClient.market.agent.unpublishAgent.mutate({ identifier });
   }
 
   // Deprecate agent (permanently hide, cannot be republished)
   async deprecateAgent(identifier: string): Promise<void> {
-    return this.request(MARKET_ENDPOINTS.deprecateAgent(identifier), {
-      method: 'POST',
-    });
+    await lambdaClient.market.agent.deprecateAgent.mutate({ identifier });
   }
 
   // Get own agents (requires authentication)
   async getOwnAgents(params?: GetOwnAgentsParams): Promise<AgentListResponse> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.getOwnAgents}?${queryString}`
-      : MARKET_ENDPOINTS.getOwnAgents;
-
-    return this.request(url, {
-      method: 'GET',
-    });
+    return lambdaClient.market.agent.getOwnAgents.query(params) as Promise<AgentListResponse>;
   }
 }
 

package/src/services/social.ts

@@ -1,4 +1,4 @@
-import { MARKET_ENDPOINTS } from '@/services/_url';
+import { lambdaClient } from '@/libs/trpc/client';
 
 export type SocialTargetType = 'agent' | 'plugin';
 
@@ -74,108 +74,57 @@ export interface FavoritePluginItem {
 }
 
 class SocialService {
-  private accessToken?: string;
-
-  // eslint-disable-next-line no-undef
-  private async request<T>(endpoint: string, init?: RequestInit): Promise<T> {
-    const headers = new Headers(init?.headers);
-
-    if (init?.body && !headers.has('content-type')) {
-      headers.set('content-type', 'application/json');
-    }
-
-    if (this.accessToken && !headers.has('authorization')) {
-      headers.set('authorization', `Bearer ${this.accessToken}`);
-    }
-
-    const response = await fetch(endpoint, {
-      ...init,
-      credentials: init?.credentials ?? 'same-origin',
-      headers,
-    });
-
-    if (!response.ok) {
-      let message = 'Unknown error';
-
-      try {
-        const errorBody = await response.json();
-        message = errorBody?.message ?? message;
-      } catch {
-        message = await response.text();
-      }
-
-      throw new Error(message || 'Social request failed');
-    }
-
-    if (response.status === 204) {
-      return undefined as T;
-    }
-
-    return (await response.json()) as T;
-  }
-
-  setAccessToken(token: string | undefined) {
-    this.accessToken = token;
+  /**
+   * @deprecated This method is no longer needed as authentication is now handled
+   * automatically through tRPC middleware. Keeping for backward compatibility.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setAccessToken(_token: string | undefined) {
+    // No-op: Authentication is now handled through tRPC authedProcedure middleware
   }
 
   // ==================== Follow ====================
 
   async follow(followingId: number): Promise<void> {
-    await this.request(MARKET_ENDPOINTS.follow, {
-      body: JSON.stringify({ followingId }),
-      method: 'POST',
-    });
+    await lambdaClient.market.social.follow.mutate({ followingId });
   }
 
   async unfollow(followingId: number): Promise<void> {
-    await this.request(MARKET_ENDPOINTS.unfollow, {
-      body: JSON.stringify({ followingId }),
-      method: 'POST',
-    });
+    await lambdaClient.market.social.unfollow.mutate({ followingId });
   }
 
   async checkFollowStatus(userId: number): Promise<FollowStatus> {
-    return this.request(MARKET_ENDPOINTS.followStatus(userId), {
-      method: 'GET',
-    });
+    return lambdaClient.market.social.checkFollowStatus.query({
+      targetUserId: userId,
+    }) as Promise<FollowStatus>;
   }
 
   async getFollowCounts(userId: number): Promise<FollowCounts> {
-    return this.request(MARKET_ENDPOINTS.followCounts(userId), {
-      method: 'GET',
-    });
+    return lambdaClient.market.social.getFollowCounts.query({
+      userId,
+    }) as Promise<FollowCounts>;
   }
 
   async getFollowing(
     userId: number,
     params?: PaginationParams,
   ): Promise<PaginatedResponse<FollowUserItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.following(userId)}?${queryString}`
-      : MARKET_ENDPOINTS.following(userId);
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getFollowing.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+      userId,
+    }) as unknown as Promise<PaginatedResponse<FollowUserItem>>;
   }
 
   async getFollowers(
     userId: number,
     params?: PaginationParams,
   ): Promise<PaginatedResponse<FollowUserItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.followers(userId)}?${queryString}`
-      : MARKET_ENDPOINTS.followers(userId);
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getFollowers.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+      userId,
+    }) as unknown as Promise<PaginatedResponse<FollowUserItem>>;
   }
 
   // ==================== Favorite ====================
@@ -184,172 +133,127 @@ class SocialService {
     targetType: SocialTargetType,
     targetIdOrIdentifier: number | string,
   ): Promise<void> {
-    const body =
+    const input =
       typeof targetIdOrIdentifier === 'string'
         ? { identifier: targetIdOrIdentifier, targetType }
         : { targetId: targetIdOrIdentifier, targetType };
 
-    await this.request(MARKET_ENDPOINTS.favorite, {
-      body: JSON.stringify(body),
-      method: 'POST',
-    });
+    await lambdaClient.market.social.addFavorite.mutate(input);
   }
 
   async removeFavorite(
     targetType: SocialTargetType,
     targetIdOrIdentifier: number | string,
   ): Promise<void> {
-    const body =
+    const input =
       typeof targetIdOrIdentifier === 'string'
         ? { identifier: targetIdOrIdentifier, targetType }
         : { targetId: targetIdOrIdentifier, targetType };
 
-    await this.request(MARKET_ENDPOINTS.unfavorite, {
-      body: JSON.stringify(body),
-      method: 'POST',
-    });
+    await lambdaClient.market.social.removeFavorite.mutate(input);
   }
 
   async checkFavoriteStatus(
     targetType: SocialTargetType,
     targetIdOrIdentifier: number | string,
   ): Promise<FavoriteStatus> {
-    return this.request(MARKET_ENDPOINTS.favoriteStatus(targetType, targetIdOrIdentifier), {
-      method: 'GET',
-    });
+    return lambdaClient.market.social.checkFavorite.query({
+      targetIdOrIdentifier,
+      targetType,
+    }) as Promise<FavoriteStatus>;
   }
 
   async getMyFavorites(params?: PaginationParams): Promise<PaginatedResponse<FavoriteItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.myFavorites}?${queryString}`
-      : MARKET_ENDPOINTS.myFavorites;
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getMyFavorites.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+    }) as unknown as Promise<PaginatedResponse<FavoriteItem>>;
   }
 
   async getUserFavoriteAgents(
     userId: number,
     params?: PaginationParams,
   ): Promise<PaginatedResponse<FavoriteAgentItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.favoriteAgents(userId)}?${queryString}`
-      : MARKET_ENDPOINTS.favoriteAgents(userId);
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getUserFavoriteAgents.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+      userId,
+    }) as unknown as Promise<PaginatedResponse<FavoriteAgentItem>>;
   }
 
   async getUserFavoritePlugins(
     userId: number,
     params?: PaginationParams,
   ): Promise<PaginatedResponse<FavoritePluginItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.favoritePlugins(userId)}?${queryString}`
-      : MARKET_ENDPOINTS.favoritePlugins(userId);
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getUserFavoritePlugins.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+      userId,
+    }) as unknown as Promise<PaginatedResponse<FavoritePluginItem>>;
   }
 
   // ==================== Like ====================
 
-  async like(
-    targetType: SocialTargetType,
-    targetIdOrIdentifier: number | string,
-  ): Promise<void> {
-    const body =
+  async like(targetType: SocialTargetType, targetIdOrIdentifier: number | string): Promise<void> {
+    const input =
       typeof targetIdOrIdentifier === 'string'
         ? { identifier: targetIdOrIdentifier, targetType }
         : { targetId: targetIdOrIdentifier, targetType };
 
-    await this.request(MARKET_ENDPOINTS.like, {
-      body: JSON.stringify(body),
-      method: 'POST',
-    });
+    await lambdaClient.market.social.like.mutate(input);
   }
 
-  async unlike(
-    targetType: SocialTargetType,
-    targetIdOrIdentifier: number | string,
-  ): Promise<void> {
-    const body =
+  async unlike(targetType: SocialTargetType, targetIdOrIdentifier: number | string): Promise<void> {
+    const input =
       typeof targetIdOrIdentifier === 'string'
         ? { identifier: targetIdOrIdentifier, targetType }
         : { targetId: targetIdOrIdentifier, targetType };
 
-    await this.request(MARKET_ENDPOINTS.unlike, {
-      body: JSON.stringify(body),
-      method: 'POST',
-    });
+    await lambdaClient.market.social.unlike.mutate(input);
   }
 
   async checkLikeStatus(
     targetType: SocialTargetType,
     targetIdOrIdentifier: number | string,
   ): Promise<LikeStatus> {
-    return this.request(MARKET_ENDPOINTS.likeStatus(targetType, targetIdOrIdentifier), {
-      method: 'GET',
-    });
+    return lambdaClient.market.social.checkLike.query({
+      targetIdOrIdentifier,
+      targetType,
+    }) as Promise<LikeStatus>;
   }
 
   async toggleLike(
     targetType: SocialTargetType,
     targetIdOrIdentifier: number | string,
   ): Promise<ToggleLikeResult> {
-    const body =
+    const input =
       typeof targetIdOrIdentifier === 'string'
         ? { identifier: targetIdOrIdentifier, targetType }
         : { targetId: targetIdOrIdentifier, targetType };
 
-    return this.request(MARKET_ENDPOINTS.toggleLike, {
-      body: JSON.stringify(body),
-      method: 'POST',
-    });
+    return lambdaClient.market.social.toggleLike.mutate(input) as Promise<ToggleLikeResult>;
   }
 
   async getUserLikedAgents(
     userId: number,
     params?: PaginationParams,
   ): Promise<PaginatedResponse<FavoriteAgentItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.likedAgents(userId)}?${queryString}`
-      : MARKET_ENDPOINTS.likedAgents(userId);
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getUserLikedAgents.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+      userId,
+    }) as unknown as Promise<PaginatedResponse<FavoriteAgentItem>>;
   }
 
   async getUserLikedPlugins(
     userId: number,
     params?: PaginationParams,
   ): Promise<PaginatedResponse<FavoritePluginItem>> {
-    const searchParams = new URLSearchParams();
-    if (params?.page) searchParams.set('page', String(params.page));
-    if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
-
-    const queryString = searchParams.toString();
-    const url = queryString
-      ? `${MARKET_ENDPOINTS.likedPlugins(userId)}?${queryString}`
-      : MARKET_ENDPOINTS.likedPlugins(userId);
-
-    return this.request(url, { method: 'GET' });
+    return lambdaClient.market.social.getUserLikedPlugins.query({
+      limit: params?.pageSize,
+      offset: params?.page ? (params.page - 1) * (params.pageSize || 10) : undefined,
+      userId,
+    }) as unknown as Promise<PaginatedResponse<FavoritePluginItem>>;
   }
 }