add post api

Signed-off-by: ふぁ <yuki@yuki0311.com>

Author: fa0311

twitter-openapi-typescript/src/apis/postApi.ts

@@ -3,8 +3,36 @@ import { DefaultFlag } from '@/types';
 import { buildHeader, entriesCursor } from '@/models/api';
 import { TwitterApiUtilsResponse } from '@/types/response';
 
+type Response<T> = Promise<TwitterApiUtilsResponse<T>>;
+
 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 {
@@ -16,39 +44,126 @@ export class PostApiUtils {
     this.flag = flag;
   }
 
-  mergeDefaultValue<T>(defaultValue: T | undefined, value: T | undefined): T {
-    if (value == undefined) return defaultValue;
-    if (defaultValue == undefined) return value;
-    if (typeof defaultValue === 'object') {
-      if (Array.isArray(value)) {
-        return value.map((v) => this.mergeDefaultValue(defaultValue[0], v)) as T;
-      } else {
-        const key = [...Object.keys(defaultValue), ...Object.keys(value)];
-        return key.reduce((v, k) => ({ ...v, [k]: this.mergeDefaultValue(defaultValue[k], value[k]) }), <T>{});
-      }
-    }
-    return value;
+  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 postCreateTweet(param: PostCreateTweetParam): Promise<TwitterApiUtilsResponse<i.CreateTweetResponse>> {
-    const value = this.mergeDefaultValue(i.PostCreateTweetRequestFromJSON(this.flag.CreateTweet), {
-      variables: {
-        tweetText: param.tweetText,
-        darkRequest: undefined,
-        media: undefined,
-        semanticAnnotationIds: undefined,
+  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 },
       },
-      features: undefined,
-      queryId: undefined,
     });
-    const response = await this.api.postCreateTweetRaw({
-      postCreateTweetRequest: value,
+    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 },
+      },
     });
-    const raw = {
-      response: response.raw,
+    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: raw,
+      raw: { response: response.raw },
       header: buildHeader(response.raw.headers),
       data: await response.value(),
     };

twitter-openapi-typescript/test/api/postApi.test.ts

@@ -4,7 +4,47 @@ test('postCreateTweet', async () => {
   logger.log('postCreateTweet');
   const client = await getClient();
   const time = new Date().toISOString();
-  const text = `Tweets from twitter-openapi-typescript🎉\n${time}`;
-  const response = await client.getPostApi().postCreateTweet({ tweetText: text });
-  expect(0).toBe(0);
+  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);
 });