twitter-openapi-typescript 0.0.1

package/src/api.ts

@@ -0,0 +1,118 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import {
+  DefaultApiUtils,
+  InitialStateApiUtils,
+  PostApiUtils,
+  TweetApiUtils,
+  UserApiUtils,
+  UserListApiUtils,
+  V11GetApiUtils,
+  V11PostApiUtils,
+  V20GetApiUtils,
+} from '@/apis';
+import { DefaultFlag } from '@/types/flag';
+
+type TwitterOpenApiParams = {
+  lang?: string;
+};
+
+export class TwitterOpenApi {
+  static hash = 'd5ccc25869b68cbb39c68fa81a1fa77967a667da';
+  static url = `https://raw.githubusercontent.com/fa0311/twitter-openapi/${this.hash}/src/config/placeholder.json`;
+  static userAgent =
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36';
+  static bearer =
+    'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+  param: TwitterOpenApiParams;
+
+  constructor(param: TwitterOpenApiParams = {}) {
+    this.param = param;
+  }
+
+  async getClientFromCookies(ct0: string, authToken: string): Promise<TwitterOpenApiClient> {
+    const config: i.ConfigurationParameters = {
+      middleware: [
+        {
+          pre: async (context) => {
+            const cookie = [
+              {
+                name: 'auth_token',
+                value: authToken,
+              },
+              {
+                name: 'ct0',
+                value: ct0,
+              },
+            ]
+              .map((cookie) => `${cookie.name}=${cookie.value}`)
+              .join('; ');
+
+            if (context.init.headers) {
+              const headers = context.init.headers as i.HTTPHeaders;
+              headers['cookie'] = cookie;
+            }
+            return context;
+          },
+        },
+      ],
+      apiKey: (key) => {
+        return {
+          'user-agent': TwitterOpenApi.userAgent,
+          'x-twitter-client-language': this.param.lang ?? 'en',
+          'x-twitter-active-user': 'yes',
+          'x-twitter-auth-type': 'OAuth2Session',
+          'x-csrf-token': ct0,
+        }[key]!;
+      },
+      accessToken: TwitterOpenApi.bearer,
+    };
+    const flag = fetch(TwitterOpenApi.url, { method: 'GET' }).then((res) => res.json()) as Promise<DefaultFlag>;
+    return new TwitterOpenApiClient(new i.Configuration(config), await flag);
+  }
+}
+
+export class TwitterOpenApiClient {
+  private config: i.Configuration;
+  public flag: DefaultFlag;
+
+  constructor(config: i.Configuration, flag: DefaultFlag) {
+    this.config = config;
+    this.flag = flag;
+  }
+
+  getDefaultApi(): DefaultApiUtils {
+    return new DefaultApiUtils(new i.DefaultApi(this.config), this.flag);
+  }
+
+  getTweetApi(): TweetApiUtils {
+    return new TweetApiUtils(new i.TweetApi(this.config), this.flag);
+  }
+
+  getUserApi(): UserApiUtils {
+    return new UserApiUtils(new i.UserApi(this.config), this.flag);
+  }
+
+  getUserListApi(): UserListApiUtils {
+    return new UserListApiUtils(new i.UserListApi(this.config), this.flag);
+  }
+
+  getPostApi(): PostApiUtils {
+    return new PostApiUtils(new i.PostApi(this.config), this.flag);
+  }
+
+  getV11GetApi(): V11GetApiUtils {
+    return new V11GetApiUtils(new i.V11GetApi(this.config), this.flag);
+  }
+
+  getV11PostApi(): V11PostApiUtils {
+    return new V11PostApiUtils(new i.V11PostApi(this.config), this.flag);
+  }
+
+  getV20GetApi(): V20GetApiUtils {
+    return new V20GetApiUtils(new i.V20GetApi(this.config), this.flag);
+  }
+
+  getInitialStateApi(): InitialStateApiUtils {
+    return new InitialStateApiUtils();
+  }
+}

package/src/apis/defaultApi.ts

@@ -0,0 +1,51 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag } from '@/types';
+import { RequestParam, buildHeader } from '@/models';
+import { TwitterApiUtilsResponse } from '@/types/response';
+
+export type ProfileSpotlightsQueryParam = {
+  screenName: string;
+  extraParam?: { [key: string]: any };
+};
+
+export class DefaultApiUtils {
+  api: i.DefaultApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.DefaultApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+
+  async request<T1, T2>(param: RequestParam<T1, T2>): Promise<TwitterApiUtilsResponse<T1>> {
+    const apiFn: typeof param.apiFn = param.apiFn.bind(this.api);
+    const response = await apiFn({
+      queryId: this.flag[param.key]['queryId'],
+      variables: JSON.stringify({ ...this.flag[param.key]['variables'], ...param }),
+      features: JSON.stringify(this.flag[param.key]['features']),
+    });
+    const data = param.convertFn(await response.value());
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: data,
+    };
+  }
+
+  async getProfileSpotlightsQuery(
+    param: ProfileSpotlightsQueryParam,
+  ): Promise<TwitterApiUtilsResponse<i.UserResultByScreenName>> {
+    const args = {
+      screenName: param.screenName,
+      ...param.extraParam,
+    };
+    const response = await this.request({
+      key: 'ProfileSpotlightsQuery',
+      apiFn: this.api.getProfileSpotlightsQueryRaw,
+      convertFn: (value) => value.data.userResultByScreenName,
+      param: args,
+    });
+
+    return response;
+  }
+}

package/src/apis/index.ts

@@ -0,0 +1,9 @@
+export { DefaultApiUtils } from './defaultApi';
+export { TweetApiUtils } from './tweetApi';
+export { PostApiUtils } from './postApi';
+export { UserApiUtils } from './userApi';
+export { UserListApiUtils } from './userListApi';
+export { V11GetApiUtils } from './v11GetApi';
+export { V11PostApiUtils } from './v11PostApi';
+export { V20GetApiUtils } from './v20GetApi';
+export { InitialStateApiUtils } from './initialStateApi';

package/src/apis/initialStateApi.ts

@@ -0,0 +1,3 @@
+export class InitialStateApiUtils {
+  // todo
+}

package/src/apis/postApi.ts

@@ -0,0 +1,169 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag } from '@/types';
+import { buildHeader, entriesCursor } from '@/models';
+import { TwitterApiUtilsResponse } from '@/types';
+
+type PostCreateTweetParam = {
+  tweetText: string;
+  extraParam?: { [key: string]: any };
+};
+
+type PostDeleteTweetParam = {
+  tweetId: string;
+  extraParam?: { [key: string]: any };
+};
+
+type PostCreateRetweetParam = {
+  tweetId: string;
+  extraParam?: { [key: string]: any };
+};
+
+type PostDeleteRetweetParam = {
+  sourceTweetId: string;
+  extraParam?: { [key: string]: any };
+};
+
+type PostFavoriteTweetParam = {
+  tweetId: string;
+  extraParam?: { [key: string]: any };
+};
+
+type PostUnfavoriteTweetParam = {
+  tweetId: string;
+  extraParam?: { [key: string]: any };
+};
+
+export class PostApiUtils {
+  api: i.PostApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.PostApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+
+  async postCreateTweet(param: PostCreateTweetParam): Promise<TwitterApiUtilsResponse<i.CreateTweetResponse>> {
+    const args = {
+      tweetText: param.tweetText,
+      ...param.extraParam,
+    };
+    const queryId = 'CreateTweet';
+    const features = i.PostCreateTweetRequestFeaturesFromJSON(this.flag[queryId]['features']);
+    const variables = i.PostCreateTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+    const response = await this.api.postCreateTweetRaw({
+      postCreateTweetRequest: {
+        queryId: queryId,
+        features: features,
+        variables: { ...variables, ...args },
+      },
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: await response.value(),
+    };
+  }
+
+  async postDeleteTweet(param: PostDeleteTweetParam): Promise<TwitterApiUtilsResponse<i.DeleteTweetResponse>> {
+    const args = {
+      tweetId: param.tweetId,
+      ...param.extraParam,
+    };
+    const queryId = 'DeleteTweet';
+    const variables = i.PostDeleteTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+    const response = await this.api.postDeleteTweetRaw({
+      postDeleteTweetRequest: {
+        queryId: queryId,
+        variables: { ...variables, ...args },
+      },
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: await response.value(),
+    };
+  }
+
+  async postCreateRetweet(param: PostCreateRetweetParam): Promise<TwitterApiUtilsResponse<i.CreateRetweetResponse>> {
+    const args = {
+      tweetId: param.tweetId,
+      ...param.extraParam,
+    };
+    const queryId = 'CreateRetweet';
+    const variables = i.PostCreateTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+    const response = await this.api.postCreateRetweetRaw({
+      postCreateRetweetRequest: {
+        queryId: queryId,
+        variables: { ...variables, ...args },
+      },
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: await response.value(),
+    };
+  }
+  async postDeleteRetweet(param: PostDeleteRetweetParam): Promise<TwitterApiUtilsResponse<i.DeleteRetweetResponse>> {
+    const args = {
+      sourceTweetId: param.sourceTweetId,
+      ...param.extraParam,
+    };
+    const queryId = 'DeleteRetweet';
+    const variables = i.PostDeleteRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+    const response = await this.api.postDeleteRetweetRaw({
+      postDeleteRetweetRequest: {
+        queryId: queryId,
+        variables: { ...variables, ...args },
+      },
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: await response.value(),
+    };
+  }
+
+  async postFavoriteTweet(
+    param: PostFavoriteTweetParam,
+  ): Promise<TwitterApiUtilsResponse<i.FavoriteTweetResponseData>> {
+    const args = {
+      tweetId: param.tweetId,
+      ...param.extraParam,
+    };
+    const queryId = 'FavoriteTweet';
+    const variables = i.PostDeleteTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+    const response = await this.api.postFavoriteTweetRaw({
+      postFavoriteTweetRequest: {
+        queryId: queryId,
+        variables: { ...variables, ...args },
+      },
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: await response.value(),
+    };
+  }
+
+  async postUnfavoriteTweet(
+    param: PostUnfavoriteTweetParam,
+  ): Promise<TwitterApiUtilsResponse<i.UnfavoriteTweetResponseData>> {
+    const args = {
+      tweetId: param.tweetId,
+      ...param.extraParam,
+    };
+    const queryId = 'UnfavoriteTweet';
+    const variables = i.PostDeleteTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
+    const response = await this.api.postUnfavoriteTweetRaw({
+      postUnfavoriteTweetRequest: {
+        queryId: queryId,
+        variables: { ...variables, ...args },
+      },
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: await response.value(),
+    };
+  }
+}

package/src/apis/tweetApi.ts

@@ -0,0 +1,244 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag, TweetListApiUtilsResponse, ApiUtilsRaw } from '@/types';
+import { RequestParam, buildHeader, entriesCursor, instructionToEntry, tweetEntriesConverter } from '@/models';
+
+type GetTweetDetailParam = {
+  focalTweetId: string;
+  cursor?: string;
+  controllerData?: string;
+  extraParam?: { [key: string]: any };
+};
+
+type GetHomeTimelineParam = {
+  couser?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetHomeLatestTimelineParam = {
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetListLatestTweetsTimelineParam = {
+  listId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetUserTweetsParam = {
+  userId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetUserTweetsAndRepliesParam = {
+  userId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetUserMediaParam = {
+  userId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetLikesParam = {
+  userId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetBookmarksParam = {
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+export class TweetApiUtils {
+  api: i.TweetApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.TweetApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+
+  async request<T>(param: RequestParam<i.InstructionUnion[], T>): Promise<TweetListApiUtilsResponse> {
+    const apiFn: typeof param.apiFn = param.apiFn.bind(this.api);
+    const response = await apiFn({
+      queryId: this.flag[param.key]['queryId'],
+      variables: JSON.stringify({ ...this.flag[param.key]['variables'], ...param }),
+      features: JSON.stringify(this.flag[param.key]['features']),
+    });
+    const instruction = param.convertFn(await response.value());
+    const entry = instructionToEntry(instruction);
+    const data = tweetEntriesConverter(entry);
+    const raw: ApiUtilsRaw = {
+      response: response.raw,
+      instruction: instruction,
+      entry: entry,
+    };
+    return {
+      raw: raw,
+      header: buildHeader(response.raw.headers),
+      cursor: entriesCursor(entry),
+      data: data,
+    };
+  }
+
+  async getTweetDetail(param: GetTweetDetailParam): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      focalTweetId: param.focalTweetId,
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...(param.controllerData == null ? {} : { controller_data: param.controllerData }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getTweetDetailRaw,
+      convertFn: (e) => e.data.threadedConversationWithInjectionsV2.instructions,
+      key: 'TweetDetail',
+      param: args,
+    });
+    return response;
+  }
+
+  async getHomeTimeline(param: GetHomeTimelineParam = {}): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.couser == null ? {} : { couser: param.couser }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getHomeTimelineRaw,
+      convertFn: (e) => e.data.home.homeTimelineUrt.instructions,
+      key: 'HomeTimeline',
+      param: args,
+    });
+    return response;
+  }
+
+  async getHomeLatestTimeline(param: GetHomeLatestTimelineParam = {}): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getHomeLatestTimelineRaw,
+      convertFn: (e) => e.data.home.homeTimelineUrt.instructions,
+      key: 'HomeLatestTimeline',
+      param: args,
+    });
+    return response;
+  }
+
+  async getListLatestTweetsTimeline(param: GetListLatestTweetsTimelineParam): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      listId: param.listId,
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getListLatestTweetsTimelineRaw,
+      convertFn: (e) => e.data.list.tweetsTimeline.timeline.instructions,
+      key: 'ListLatestTweetsTimeline',
+      param: args,
+    });
+    return response;
+  }
+
+  async getUserTweets(param: GetUserTweetsParam): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      userId: param.userId,
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getUserTweetsRaw,
+      convertFn: (e) => e.data.user.result.timelineV2.timeline.instructions,
+      key: 'UserTweets',
+      param: args,
+    });
+    return response;
+  }
+
+  async getUserTweetsAndReplies(param: GetUserTweetsAndRepliesParam): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      userId: param.userId,
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getUserTweetsAndRepliesRaw,
+      convertFn: (e) => e.data.user.result.timelineV2.timeline.instructions,
+      key: 'UserTweetsAndReplies',
+      param: args,
+    });
+    return response;
+  }
+
+  async getUserMedia(param: GetUserMediaParam): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      userId: param.userId,
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getUserMediaRaw,
+      convertFn: (e) => e.data.user.result.timelineV2.timeline.instructions,
+      key: 'UserMedia',
+      param: args,
+    });
+    return response;
+  }
+  async getLikes(param: GetLikesParam): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      userId: param.userId,
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getLikesRaw,
+      convertFn: (e) => e.data.user.result.timelineV2.timeline.instructions,
+      key: 'Likes',
+      param: args,
+    });
+    return response;
+  }
+  async getBookmarks(param: GetBookmarksParam = {}): Promise<TweetListApiUtilsResponse> {
+    const args = {
+      ...(param.count == null ? {} : { count: param.count }),
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...param.extraParam,
+    };
+
+    const response = await this.request({
+      apiFn: this.api.getBookmarksRaw,
+      convertFn: (e) => e.data.bookmarkTimelineV2.timeline.instructions,
+      key: 'Bookmarks',
+      param: args,
+    });
+    return response;
+  }
+}

package/src/apis/userApi.ts

@@ -0,0 +1,47 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { UserApiUtilsRaw, DefaultFlag, UserApiUtilsResponse } from '@/types';
+import { RequestParam, buildHeader } from '@/models';
+
+type getUserByScreenNameParam = {
+  screenName: string;
+  extraParam?: { [key: string]: any };
+};
+
+export class UserApiUtils {
+  api: i.UserApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.UserApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+
+  async request<T>(param: RequestParam<i.UserResults, T>): Promise<UserApiUtilsResponse> {
+    const apiFn: typeof param.apiFn = param.apiFn.bind(this.api);
+    const response = await apiFn({
+      queryId: this.flag[param.key]['queryId'],
+      variables: JSON.stringify({ ...this.flag[param.key]['variables'], ...param }),
+      features: JSON.stringify(this.flag[param.key]['features']),
+    });
+    const user = param.convertFn(await response.value());
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: user.result,
+    };
+  }
+
+  async getUserByScreenName(param: getUserByScreenNameParam): Promise<UserApiUtilsResponse> {
+    const args = {
+      screenName: param.screenName,
+      ...param.extraParam,
+    };
+    const response = this.request({
+      key: 'UserByScreenName',
+      apiFn: this.api.getUserByScreenNameRaw,
+      convertFn: (e) => e.data.user,
+      param: args,
+    });
+    return response;
+  }
+}