twitter-openapi-typescript 0.0.1

package/src/apis/userListApi.ts

@@ -0,0 +1,90 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag, ApiUtilsRaw, UserListApiUtilsResponse } from '@/types';
+import {
+  RequestParam,
+  buildHeader,
+  buildUserResponse,
+  entriesCursor,
+  instructionToEntry,
+  userEntriesConverter,
+} from '@/models';
+
+type GetFollowers = {
+  userId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+type GetFollowing = {
+  userId: string;
+  cursor?: string;
+  count?: number;
+  extraParam?: { [key: string]: any };
+};
+
+export class UserListApiUtils {
+  api: i.UserListApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.UserListApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+
+  async request<T>(param: RequestParam<i.InstructionUnion[], T>): Promise<UserListApiUtilsResponse> {
+    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 userList = userEntriesConverter(entry);
+    const data = userList.map((user) => buildUserResponse(user));
+
+    const raw: ApiUtilsRaw = {
+      response: response.raw,
+      instruction: instruction,
+      entry: entry,
+    };
+    return {
+      raw: raw,
+      header: buildHeader(response.raw.headers),
+      cursor: entriesCursor(entry),
+      data: data,
+    };
+  }
+
+  async getFollowers(param: GetFollowers): Promise<UserListApiUtilsResponse> {
+    const args = {
+      userId: param.userId,
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...(param.count == null ? {} : { count: param.count }),
+      ...param.extraParam,
+    };
+    const response = await this.request({
+      apiFn: this.api.getFollowersRaw,
+      convertFn: (e) => e.data.user.result.timeline.timeline.instructions,
+      key: 'Followers',
+      param: args,
+    });
+    return response;
+  }
+  async getFollowing(param: GetFollowing): Promise<UserListApiUtilsResponse> {
+    const args = {
+      userId: param.userId,
+      ...(param.cursor == null ? {} : { cursor: param.cursor }),
+      ...(param.count == null ? {} : { count: param.count }),
+      ...param.extraParam,
+    };
+    const response = await this.request({
+      apiFn: this.api.getFollowingRaw,
+      convertFn: (e) => e.data.user.result.timeline.timeline.instructions,
+      key: 'Following',
+      param: args,
+    });
+    return response;
+  }
+}

package/src/apis/v11GetApi.ts

@@ -0,0 +1,12 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag } from '@/types';
+
+export class V11GetApiUtils {
+  api: i.V11GetApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.V11GetApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+}

package/src/apis/v11PostApi.ts

@@ -0,0 +1,73 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag, TwitterApiUtilsResponse } from '@/types';
+import { buildHeader } from '@/models';
+
+type PostCreateFriendshipsParam = {
+  userId: string;
+  extraParam?: { [key: string]: any };
+};
+
+type PostDestroyFriendshipsParam = {
+  userId: string;
+  extraParam?: { [key: string]: any };
+};
+
+export class V11PostApiUtils {
+  api: i.V11PostApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.V11PostApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+
+  async postCreateFriendships(param: PostCreateFriendshipsParam): Promise<TwitterApiUtilsResponse<undefined>> {
+    const response = await this.api.postCreateFriendshipsRaw({
+      includeBlockedBy: 1,
+      includeBlocking: 1,
+      includeCanDm: 1,
+      includeCanMediaTag: 1,
+      includeExtHasNftAvatar: 1,
+      includeExtIsBlueVerified: 1,
+      includeExtProfileImageShape: 1,
+      includeExtVerifiedType: 1,
+      includeFollowedBy: 1,
+      includeMuteEdge: 1,
+      includeProfileInterstitialType: 1,
+      includeWantRetweets: 1,
+      skipStatus: 1,
+      userId: param.userId,
+      ...param.extraParam,
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: undefined,
+    };
+  }
+
+  async postDestroyFriendships(param: PostDestroyFriendshipsParam): Promise<TwitterApiUtilsResponse<undefined>> {
+    const response = await this.api.postDestroyFriendshipsRaw({
+      includeBlockedBy: 0,
+      includeBlocking: 0,
+      includeCanDm: 0,
+      includeCanMediaTag: 0,
+      includeExtHasNftAvatar: 0,
+      includeExtIsBlueVerified: 0,
+      includeExtProfileImageShape: 0,
+      includeExtVerifiedType: 0,
+      includeFollowedBy: 0,
+      includeMuteEdge: 0,
+      includeProfileInterstitialType: 0,
+      includeWantRetweets: 0,
+      skipStatus: 0,
+      userId: param.userId,
+      ...param.extraParam,
+    });
+    return {
+      raw: { response: response.raw },
+      header: buildHeader(response.raw.headers),
+      data: undefined,
+    };
+  }
+}

package/src/apis/v20GetApi.ts

@@ -0,0 +1,12 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { DefaultFlag } from '@/types';
+
+export class V20GetApiUtils {
+  api: i.V20GetApi;
+  flag: DefaultFlag;
+
+  constructor(api: i.V20GetApi, flag: DefaultFlag) {
+    this.api = api;
+    this.flag = flag;
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from '@/apis';
+export * from '@/models';
+export * from '@/types';
+export * from '@/api';

package/src/models/api.ts

@@ -0,0 +1,129 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { TweetApiUtilsData, UserApiUtilsData, CursorApiUtilsResponse, ApiUtilsHeader } from '@/types';
+
+export const instructionToEntry = (item: i.InstructionUnion[]): i.TimelineAddEntry[] => {
+  return item
+    .map((e) => (e.type == i.InstructionType.TimelineAddEntries ? (e as i.TimelineAddEntries) : null))
+    .find((e) => e).entries;
+};
+
+export const tweetEntriesConverter = (item: i.TimelineAddEntry[]): TweetApiUtilsData[] => {
+  return item
+    .map((e) => {
+      if (e.content.entryType == i.ContentEntryType.TimelineTimelineItem) {
+        const item = (e.content as i.TimelineTimelineItem).itemContent;
+        const timeline = item.itemType == i.ContentItemType.TimelineTweet ? (item as i.TimelineTweet) : null;
+        if (timeline == null) return null;
+        return buildTweetApiUtils({
+          result: timeline.tweetResults,
+          promotedMetadata: timeline.promotedMetadata,
+        });
+      } else if (e.content.entryType == i.ContentEntryType.TimelineTimelineModule) {
+        const item = (e.content as i.TimelineTimelineModule).items ?? [];
+        const timelineList = item
+          .filter((e) => e.item.itemContent.itemType == i.ContentItemType.TimelineTweet)
+          .map((e) => e.item.itemContent as i.TimelineTweet);
+        if (timelineList.length == 0) return null;
+        const timeline = timelineList[0];
+        return buildTweetApiUtils({
+          result: timeline.tweetResults,
+          promotedMetadata: timeline.promotedMetadata,
+          reply: timelineList.slice(1),
+        });
+      }
+    })
+    .filter((e): e is NonNullable<typeof e> => e != null);
+};
+
+type buildTweetApiUtilsArgs = {
+  result: i.ItemResult;
+  promotedMetadata?: any;
+  reply?: i.TimelineTweet[];
+};
+export const buildTweetApiUtils = (args: buildTweetApiUtilsArgs): TweetApiUtilsData | undefined => {
+  const tweet = tweetResultsConverter(args.result);
+  if (tweet == null) return undefined;
+  const quoted = tweet.quotedStatusResult;
+  const retweeted = tweet.legacy.retweetedStatusResult;
+  return {
+    raw: args.result,
+    promotedMetadata: args.promotedMetadata,
+    tweet: tweet,
+    user: tweet.core.userResults.result,
+    reply:
+      args.reply
+        ?.map((e) => buildTweetApiUtils({ result: e.tweetResults, promotedMetadata: e.promotedMetadata }))
+        .filter((e): e is NonNullable<typeof e> => e != null) ?? [],
+    quoted: quoted == undefined ? undefined : buildTweetApiUtils({ result: quoted }),
+  };
+};
+
+export const tweetResultsConverter = (tweetResults: i.ItemResult): i.Tweet | undefined => {
+  switch (tweetResults.result.typename) {
+    case i.TypeName.Tweet:
+      return tweetResults.result as i.Tweet;
+    case i.TypeName.TweetWithVisibilityResults:
+      return (tweetResults.result as i.TweetWithVisibilityResults).tweet;
+    case i.TypeName.TweetTombstone:
+      return undefined;
+  }
+  throw Error();
+};
+
+export const userEntriesConverter = (item: i.TimelineAddEntry[]): i.TimelineUser[] => {
+  return item
+    .map((e) => {
+      if (e.content.typename == i.TypeName.TimelineTimelineItem) {
+        const item = (e.content as i.TimelineTimelineItem).itemContent;
+        return item.itemType == i.ContentItemType.TimelineUser ? (item as i.TimelineUser) : null;
+      }
+    })
+    .filter((e): e is NonNullable<typeof e> => e != null);
+};
+
+export const buildUserResponse = (user: i.TimelineUser): UserApiUtilsData => {
+  return {
+    raw: user,
+    user: user.userResults.result,
+  };
+};
+
+export const entriesCursor = (item: i.TimelineAddEntry[]): CursorApiUtilsResponse => {
+  const cursorList = item
+    .map((e) => {
+      if (e.content.entryType == i.ContentEntryType.TimelineTimelineCursor) {
+        return e.content as i.TimelineTimelineCursor;
+      } else if (e.content.entryType == i.ContentEntryType.TimelineTimelineItem) {
+        const item = e.content as i.TimelineTimelineItem;
+        if (item.itemContent.itemType == i.ContentItemType.TimelineTimelineCursor) {
+          return item.itemContent as i.TimelineTimelineCursor;
+        }
+      }
+    })
+    .filter((e): e is NonNullable<typeof e> => e != null);
+  return buildCursor(cursorList);
+};
+
+export const buildCursor = (cursorList: i.TimelineTimelineCursor[]): CursorApiUtilsResponse => {
+  return {
+    top: cursorList.find((e) => e.cursorType == i.TimelineTimelineCursorCursorTypeEnum.Top),
+    bottom: cursorList.find((e) => e.cursorType == i.TimelineTimelineCursorCursorTypeEnum.Bottom),
+  };
+};
+
+export const buildHeader = (headers: Headers): ApiUtilsHeader => {
+  return {
+    raw: headers,
+    connectionHash: headers.get('x-connection-hash'),
+    contentTypeOptions: headers.get('x-content-type-options'),
+    frameOptions: headers.get('x-frame-options'),
+    rateLimitLimit: Number(headers.get('x-rate-limit-limit')),
+    rateLimitRemaining: Number(headers.get('x-rate-limit-remaining')),
+    rateLimitReset: Number(headers.get('x-rate-limit-reset')),
+    responseTime: Number(headers.get('x-response-time')),
+    tfePreserveBody: headers.get('x-tfe-preserve-body') == 'true',
+    transactionId: headers.get('x-transaction-id'),
+    twitterResponseTags: headers.get('x-twitter-response-tags'),
+    xssProtection: Number(headers.get('x-xss-protection')),
+  };
+};

package/src/models/index.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './type';

package/src/models/type.ts

@@ -0,0 +1,16 @@
+import * as i from 'twitter-openapi-typescript-generated';
+
+export type ApiFunction<T> = (requestParameters: {
+  queryId: string;
+  variables: string;
+  features: string;
+}) => Promise<i.ApiResponse<T>>;
+
+export type RequestParam<T1, T2> = {
+  apiFn: ApiFunction<T2>;
+  convertFn: ConvertFunction<T1, T2>;
+  key: string;
+  param: { [key: string]: any };
+};
+
+export type ConvertFunction<T1, T2> = (arg0: T2) => T1;

package/src/types/flag.ts

@@ -0,0 +1,5 @@
+export type DefaultFlag = {
+  [key: string]: {
+    [key: string]: any;
+  };
+};

package/src/types/header.ts

@@ -0,0 +1,14 @@
+export type ApiUtilsHeader = {
+  raw: Headers;
+  connectionHash: string | null;
+  contentTypeOptions: string | null;
+  frameOptions: string | null;
+  rateLimitLimit: number;
+  rateLimitRemaining: number;
+  rateLimitReset: number;
+  responseTime: number;
+  tfePreserveBody: boolean;
+  transactionId: string | null;
+  twitterResponseTags: string | null;
+  xssProtection: number;
+};

package/src/types/index.ts

@@ -0,0 +1,7 @@
+export * from './flag';
+export * from './header';
+export * from './timeline';
+export * from './tweet';
+export * from './user_list';
+export * from './user';
+export * from './response';

package/src/types/response.ts

@@ -0,0 +1,11 @@
+import { ApiUtilsHeader } from '@/types';
+
+export type TwitterApiUtilsResponse<T> = {
+  raw: TwitterApiUtilsRaw;
+  header: ApiUtilsHeader;
+  data: T;
+};
+
+export type TwitterApiUtilsRaw = {
+  response: Response;
+};

package/src/types/timeline.ts

@@ -0,0 +1,12 @@
+import * as i from 'twitter-openapi-typescript-generated';
+
+export type CursorApiUtilsResponse = {
+  bottom?: i.TimelineTimelineCursor;
+  top?: i.TimelineTimelineCursor;
+};
+
+export type ApiUtilsRaw = {
+  response: Response;
+  instruction: i.InstructionUnion[];
+  entry: i.TimelineAddEntry[];
+};

package/src/types/tweet.ts

@@ -0,0 +1,19 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { CursorApiUtilsResponse, ApiUtilsRaw, ApiUtilsHeader } from '@/types';
+
+export type TweetListApiUtilsResponse = {
+  raw: ApiUtilsRaw;
+  header: ApiUtilsHeader;
+  cursor: CursorApiUtilsResponse;
+  data: TweetApiUtilsData[];
+};
+
+export type TweetApiUtilsData = {
+  raw: i.ItemResult;
+  tweet: i.Tweet;
+  user: i.User;
+  reply: TweetApiUtilsData[];
+  quoted?: TweetApiUtilsData;
+  retweeted?: TweetApiUtilsData;
+  promotedMetadata?: any;
+};

package/src/types/user.ts

@@ -0,0 +1,12 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { ApiUtilsHeader } from '@/types';
+
+export type UserApiUtilsResponse = {
+  raw: UserApiUtilsRaw;
+  header: ApiUtilsHeader;
+  data: i.User;
+};
+
+export type UserApiUtilsRaw = {
+  response: Response;
+};

package/src/types/user_list.ts

@@ -0,0 +1,14 @@
+import * as i from 'twitter-openapi-typescript-generated';
+import { ApiUtilsRaw, CursorApiUtilsResponse, ApiUtilsHeader } from '@/types';
+
+export type UserListApiUtilsResponse = {
+  raw: ApiUtilsRaw;
+  header: ApiUtilsHeader;
+  cursor: CursorApiUtilsResponse;
+  data: UserApiUtilsData[];
+};
+
+export type UserApiUtilsData = {
+  raw: i.TimelineUser;
+  user: i.User;
+};

package/test/api/defaultApi.test.ts

@@ -0,0 +1,13 @@
+import { getClient, logger } from '@test/init';
+import { printTweet } from '@test/util';
+
+test('getProfileSpotlightsQuery', async () => {
+  logger.log('getProfileSpotlightsQuery');
+  const client = await getClient();
+  const response = await client.getDefaultApi().getProfileSpotlightsQuery({ screenName: 'elonmusk' });
+  const legacy = response.data.result.legacy;
+  logger.log(legacy.screenName);
+  logger.log(`followedBy: ${legacy.followedBy} following: ${legacy.following}`);
+  logger.log('┄'.repeat(50));
+  expect(response.raw.response.ok).toBe(true);
+});

package/test/api/postApi.test.ts

@@ -0,0 +1,50 @@
+import { getClient, logger } from '@test/init';
+
+test('postCreateTweet', async () => {
+  logger.log('postCreateTweet');
+  const client = await getClient();
+  const time = new Date().toISOString();
+  const response = await client.getPostApi().postCreateTweet({ tweetText: `Test[${time}]` });
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('postDeleteTweet', async () => {
+  logger.log('postDeleteTweet');
+  const client = await getClient();
+  const time = new Date().toISOString();
+  const response = await client.getPostApi().postCreateTweet({ tweetText: `Test[${time}]` });
+  expect(response.raw.response.ok).toBe(true);
+  const tweetId = response.data.data.createTweet.tweetResults.result.restId;
+  logger.log(tweetId);
+
+  const response2 = await client.getPostApi().postDeleteTweet({ tweetId: tweetId });
+  expect(response2.raw.response.ok).toBe(true);
+});
+
+test('postCreateRetweet', async () => {
+  logger.log('postCreateRetweet');
+  const client = await getClient();
+  const response = await client.getPostApi().postCreateRetweet({ tweetId: '1349129669258448897' });
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('postDeleteRetweet', async () => {
+  logger.log('postDeleteRetweet');
+  const client = await getClient();
+  const response = await client.getPostApi().postDeleteRetweet({ sourceTweetId: '1349129669258448897' });
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('postFavoriteTweet', async () => {
+  logger.log('postFavoriteTweet');
+  const client = await getClient();
+  const response = await client.getPostApi().postFavoriteTweet({ tweetId: '1349129669258448897' });
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('postUnfavoriteTweet', async () => {
+  logger.log('postUnfavoriteTweet');
+  const client = await getClient();
+  const response = await client.getPostApi().postUnfavoriteTweet({ tweetId: '1349129669258448897' });
+  expect(response.raw.response.ok).toBe(true);
+});

package/test/api/tweetApi.test.ts

@@ -0,0 +1,74 @@
+import { getClient, logger } from '@test/init';
+import { printTweet } from '@test/util';
+
+test('getTweetDetail', async () => {
+  logger.log('getTweetDetail');
+  const client = await getClient();
+  const response = await client.getTweetApi().getTweetDetail({ focalTweetId: '1349129669258448897' });
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getHomeTimeline', async () => {
+  logger.log('getHomeTimeline');
+  const client = await getClient();
+  const response = await client.getTweetApi().getHomeTimeline();
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getHomeLatestTimeline', async () => {
+  logger.log('getHomeLatestTimeline');
+  const client = await getClient();
+  const response = await client.getTweetApi().getHomeLatestTimeline();
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getListLatestTweetsTimeline', async () => {
+  logger.log('getListLatestTweetsTimeline');
+  const client = await getClient();
+  const response = await client.getTweetApi().getListLatestTweetsTimeline({ listId: '1141162794290520064' });
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getUserTweets', async () => {
+  logger.log('getUserTweets');
+  const client = await getClient();
+  const response = await client.getTweetApi().getUserTweets({ userId: '44196397' });
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getUserTweetsAndReplies', async () => {
+  logger.log('getUserTweetsAndReplies');
+  const client = await getClient();
+  const response = await client.getTweetApi().getUserTweetsAndReplies({ userId: '44196397' });
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getUserMedia', async () => {
+  logger.log('getUserMedia');
+  const client = await getClient();
+  const response = await client.getTweetApi().getUserMedia({ userId: '44196397' });
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getLikes', async () => {
+  logger.log('getLikes');
+  const client = await getClient();
+  const response = await client.getTweetApi().getLikes({ userId: '44196397' });
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getBookmarks', async () => {
+  logger.log('getBookmarks');
+  const client = await getClient();
+  const response = await client.getTweetApi().getBookmarks();
+  response.data.filter((e) => !e.promotedMetadata).forEach((e) => printTweet(e));
+  expect(response.raw.response.ok).toBe(true);
+});

package/test/api/userApi.test.ts

@@ -0,0 +1,13 @@
+import { getClient, logger } from '@test/init';
+
+test('getUserByScreenName', async () => {
+  logger.log('getUserByScreenName');
+  const client = await getClient();
+  const response = await client.getUserApi().getUserByScreenName({ screenName: 'elonmusk' });
+  const legacy = response.data.legacy;
+  logger.log(legacy.screenName);
+  logger.log(`followedBy: ${legacy.followedBy} following: ${legacy.following}`);
+  logger.log(`friendsCount: ${legacy.friendsCount} followersCount: ${legacy.followersCount}`);
+  logger.log('┄'.repeat(50));
+  expect(response.raw.response.ok).toBe(true);
+});

package/test/api/userListApi.test.ts

@@ -0,0 +1,18 @@
+import { getClient, logger } from '@test/init';
+import { printUser } from '@test/util';
+
+test('getFollowers', async () => {
+  logger.log('getFollowers');
+  const client = await getClient();
+  const response = await client.getUserListApi().getFollowers({ userId: '44196397' });
+  response.data.forEach((e) => printUser(e));
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('getFollowing', async () => {
+  logger.log('getFollowing');
+  const client = await getClient();
+  const response = await client.getUserListApi().getFollowing({ userId: '44196397' });
+  response.data.forEach((e) => printUser(e));
+  expect(response.raw.response.ok).toBe(true);
+});

package/test/api/v11PostApi.test.ts

@@ -0,0 +1,13 @@
+import { getClient, logger } from '@test/init';
+
+test('postCreateFriendships', async () => {
+  const client = await getClient();
+  const response = await client.getV11PostApi().postCreateFriendships({ userId: '44196397' });
+  expect(response.raw.response.ok).toBe(true);
+});
+
+test('postDestroyFriendships', async () => {
+  const client = await getClient();
+  const response = await client.getV11PostApi().postDestroyFriendships({ userId: '44196397' });
+  expect(response.raw.response.ok).toBe(true);
+});