@pipedream/twitter 0.3.11 → 1.0.0

package/dist/app/twitter.app.d.ts

@@ -0,0 +1,127 @@
+import OAuth from "oauth-1.0a";
+import { AddUserToListParams, CreateTweetParams, DeleteTweetParams, FollowUserParams, GetUserLikedTweetParams, GetUserOwnedListsParams, GetTweetParams, GetUserFollowedListsParams, GetUserMentionsParams, GetUserParams, GetUserTweetsParams, HttpRequestParams, LikeTweetParams, GetUserFollowersParams, GetUserFollowingParams, PaginatedRequestParams, RetweetParams, SearchTweetsParams, UnfollowUserParams, UnlikeTweetParams, GetListTweetsParams } from "../common/types/requestParams.js";
+import { List, PaginatedResponseObject, ResponseObject, Tweet, TwitterEntity, User } from "../common/types/responseSchemas.js";
+declare const _default: import("@pipedream/types").App<{
+    _getAuthHeader(config: HttpRequestParams): Promise<OAuth.Header>;
+    _getBaseUrl(): "https://api.twitter.com/2";
+    _httpRequest({ $, ...args }: HttpRequestParams): Promise<ResponseObject<TwitterEntity>>;
+    _paginatedRequest({ maxResults, maxPerPage, params, ...args }: PaginatedRequestParams): Promise<PaginatedResponseObject<TwitterEntity>>;
+    addUserToList({ listId, ...args }: AddUserToListParams): Promise<object>;
+    createTweet(args: CreateTweetParams): Promise<object>;
+    deleteTweet({ tweetId, ...args }: DeleteTweetParams): Promise<object>;
+    followUser(args: FollowUserParams): Promise<object>;
+    getListTweets({ listId, ...args }: GetListTweetsParams): Promise<PaginatedResponseObject<Tweet>>;
+    getTweet({ tweetId, ...args }: GetTweetParams): Promise<ResponseObject<Tweet>>;
+    getAuthenticatedUserId(): Promise<User["id"]>;
+    getUserLikedTweets({ userId, ...args }: GetUserLikedTweetParams): Promise<PaginatedResponseObject<Tweet>>;
+    getUserOwnedLists({ userId, ...args }: GetUserOwnedListsParams): Promise<PaginatedResponseObject<List>>;
+    getUserFollowedLists({ userId, ...args }: GetUserFollowedListsParams): Promise<PaginatedResponseObject<List>>;
+    getUserMentions({ userId, ...args }: GetUserMentionsParams): Promise<PaginatedResponseObject<Tweet>>;
+    getUserTweets({ userId, ...args }: GetUserTweetsParams): Promise<PaginatedResponseObject<Tweet>>;
+    getUserByUsername(username: string): Promise<ResponseObject<User>>;
+    getUser({ userId, ...args }: GetUserParams): Promise<ResponseObject<User>>;
+    likeTweet(args: LikeTweetParams): Promise<object>;
+    getUserFollowers({ userId, ...args }: GetUserFollowersParams): Promise<PaginatedResponseObject<User>>;
+    getUserFollowing({ userId, ...args }: GetUserFollowingParams): Promise<PaginatedResponseObject<User>>;
+    retweet(args: RetweetParams): Promise<object>;
+    searchTweets(args: SearchTweetsParams): Promise<PaginatedResponseObject<Tweet>>;
+    unfollowUser({ userId, ...args }: UnfollowUserParams): Promise<object>;
+    unlikeTweet({ tweetId, ...args }: UnlikeTweetParams): Promise<object>;
+}, {
+    maxResults: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+    };
+    listId: {
+        type: string;
+        label: string;
+        description: string;
+        options(): Promise<{
+            label: string;
+            value: string;
+        }[]>;
+    };
+    userNameOrId: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        default: string;
+    };
+    tweetId: {
+        type: string;
+        label: string;
+        description: string;
+    };
+    query: {
+        type: string;
+        label: string;
+        description: string;
+    };
+    listExpansions: {
+        type: string;
+        label: string;
+        optional: boolean;
+        description: string;
+        options: string[];
+    };
+    tweetExpansions: {
+        type: string;
+        label: string;
+        optional: boolean;
+        description: string;
+        options: string[];
+    };
+    userExpansions: {
+        type: string;
+        label: string;
+        optional: boolean;
+        description: string;
+        options: string[];
+    };
+    listFields: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        options: string[];
+    };
+    mediaFields: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        options: string[];
+    };
+    placeFields: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        options: string[];
+    };
+    pollFields: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        options: string[];
+    };
+    tweetFields: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        options: string[];
+    };
+    userFields: {
+        type: string;
+        label: string;
+        description: string;
+        optional: boolean;
+        options: string[];
+    };
+}>;
+export default _default;

package/dist/app/twitter.app.mjs

@@ -0,0 +1,341 @@
+import OAuth from "oauth-1.0a";
+import crypto from "crypto";
+import { defineApp } from "@pipedream/types";
+import { axios } from "@pipedream/platform";
+import { LIST_FIELD_OPTIONS, MEDIA_FIELD_OPTIONS, PLACE_FIELD_OPTIONS, POLL_FIELD_OPTIONS, TWEET_FIELD_OPTIONS, USER_FIELD_OPTIONS, } from "../common/dataFields.mjs";
+import { LIST_EXPANSION_OPTIONS, TWEET_EXPANSION_OPTIONS, USER_EXPANSION_OPTIONS, } from "../common/expansions.mjs";
+export default defineApp({
+    type: "app",
+    app: "twitter",
+    propDefinitions: {
+        maxResults: {
+            type: "integer",
+            label: "Max Results",
+            description: "Maximum total amount of items to return. The maximum amount of requests that can be made is 5.",
+            optional: true,
+        },
+        listId: {
+            type: "string",
+            label: "List ID",
+            description: "Select a **List** owned by the authenticated user, or use a custom *List ID*.",
+            async options() {
+                const userId = await this.getAuthenticatedUserId();
+                const lists = await this.getUserOwnedLists({
+                    userId,
+                });
+                return (lists.data?.map(({ id, name, }) => ({
+                    label: name,
+                    value: id,
+                })) ?? []);
+            },
+        },
+        userNameOrId: {
+            type: "string",
+            label: "User Name or ID",
+            description: "A Twitter username (handle) prefixed with `@` (e.g. `@pipedream`). You can also use the string `me` to use the authenticated user (default), or a numeric User ID.",
+            optional: true,
+            default: "me",
+        },
+        tweetId: {
+            type: "string",
+            label: "Tweet ID",
+            description: "The numerical ID of the tweet.",
+        },
+        query: {
+            type: "string",
+            label: "Query",
+            description: "One query for matching Tweets. See the [Twitter API guide on building queries](https://developer.twitter.com/en/docs/twitter-api/tweets/search/integrate/build-a-query).",
+        },
+        listExpansions: {
+            type: "string[]",
+            label: "Expansions",
+            optional: true,
+            description: "Additional data objects related to the List(s) to be included in the response.",
+            options: LIST_EXPANSION_OPTIONS,
+        },
+        tweetExpansions: {
+            type: "string[]",
+            label: "Expansions",
+            optional: true,
+            description: "Additional data objects related to the Tweet(s) to be included in the response.",
+            options: TWEET_EXPANSION_OPTIONS,
+        },
+        userExpansions: {
+            type: "string[]",
+            label: "Expansions",
+            optional: true,
+            description: "Additional data objects related to the User(s) to be included in the response.",
+            options: USER_EXPANSION_OPTIONS,
+        },
+        listFields: {
+            type: "string[]",
+            label: "List Fields",
+            description: "Specific [list fields](https://developer.twitter.com/en/docs/twitter-api/data-dictionary/object-model/lists) to be included in the returned list object.",
+            optional: true,
+            options: LIST_FIELD_OPTIONS,
+        },
+        mediaFields: {
+            type: "string[]",
+            label: "Media Fields",
+            description: "Specific [media fields](https://developer.twitter.com/en/docs/twitter-api/data-dictionary/object-model/media) to be included in the returned Tweet(s). Only applicable if the Tweet contains media and you've requested the `attachments.media_keys` expansion.",
+            optional: true,
+            options: MEDIA_FIELD_OPTIONS,
+        },
+        placeFields: {
+            type: "string[]",
+            label: "Place Fields",
+            description: "Specific [place fields](https://developer.twitter.com/en/docs/twitter-api/data-dictionary/object-model/place) to be included in the returned Tweet(s). Only applicable if the Tweet contains a place and you've requested the `geo.place_id` expansion.",
+            optional: true,
+            options: PLACE_FIELD_OPTIONS,
+        },
+        pollFields: {
+            type: "string[]",
+            label: "Poll Fields",
+            description: "Specific [poll fields](https://developer.twitter.com/en/docs/twitter-api/data-dictionary/object-model/poll) to be included in the returned Tweet(s). Only applicable if the Tweet contains a poll and you've requested the `attachments.poll_ids` expansion.",
+            optional: true,
+            options: POLL_FIELD_OPTIONS,
+        },
+        tweetFields: {
+            type: "string[]",
+            label: "Tweet Fields",
+            description: "Specific [tweet fields](https://developer.twitter.com/en/docs/twitter-api/data-dictionary/object-model/tweet) to be included in the returned Tweet(s). If you've requested the `referenced_tweets.id` expansion, these fields will also be returned for any included referenced Tweets.",
+            optional: true,
+            options: TWEET_FIELD_OPTIONS,
+        },
+        userFields: {
+            type: "string[]",
+            label: "User Fields",
+            description: "Specific [user fields](https://developer.twitter.com/en/docs/twitter-api/data-dictionary/object-model/user) to be included in the returned Tweet(s). Only applicable if you've requested one of the user expansions: `author_id`, `entities.mentions.username`, `in_reply_to_user_id`, `referenced_tweets.id.author_id`.",
+            optional: true,
+            options: USER_FIELD_OPTIONS,
+        },
+    },
+    methods: {
+        async _getAuthHeader(config) {
+            const { oauth_access_token: key, oauth_refresh_token: secret, } = this.$auth;
+            const consumer = {
+                key,
+                secret,
+            };
+            const oauth = new OAuth({
+                consumer,
+                signature_method: "HMAC-SHA1",
+                hash_function(base_string, key) {
+                    return crypto
+                        .createHmac("sha1", key)
+                        .update(base_string)
+                        .digest("base64");
+                },
+            });
+            if (!config.method)
+                config.method = "GET";
+            return oauth.toHeader(oauth.authorize(config, consumer));
+        },
+        _getBaseUrl() {
+            return "https://api.twitter.com/2";
+        },
+        async _httpRequest({ $ = this, ...args }) {
+            const config = {
+                baseURL: this._getBaseUrl(),
+                ...args,
+            };
+            //const headers = this._getAuthHeader(config);
+            const request = () => axios($, {
+                ...config,
+                //headers,
+            }, {
+                oauthSignerUri: this.$auth.oauth_signer_uri,
+                token: {
+                    key: this.$auth.oauth_access_token,
+                    secret: this.$auth.oauth_refresh_token,
+                },
+            });
+            let response, counter = 1;
+            do {
+                try {
+                    response = await request();
+                }
+                catch (err) {
+                    console.log(`Request error on attempt #${counter}: `, err);
+                }
+            } while (!response && ++counter < 3);
+            if (!response)
+                response = await request();
+            return response;
+        },
+        async _paginatedRequest({ maxResults = 100, maxPerPage = 100, params, ...args }) {
+            const totalData = [], totalIncludes = {};
+            let paginationToken;
+            let resultCount = 0;
+            do {
+                const perPage = Math.min(maxResults - resultCount, maxPerPage);
+                const { data, meta: { next_token }, includes, } = await this._httpRequest({
+                    params: {
+                        ...params,
+                        max_results: perPage,
+                        pagination_token: paginationToken,
+                    },
+                    ...args,
+                });
+                if (!data)
+                    break;
+                totalData.push(...(Array.isArray(data)
+                    ? data
+                    : [
+                        data,
+                    ]));
+                if (includes) {
+                    Object.entries(includes).forEach(([key, value]) => {
+                        if (!totalIncludes[key])
+                            totalIncludes[key] = [];
+                        totalIncludes[key].push(...value);
+                    });
+                }
+                paginationToken = next_token;
+                resultCount += perPage;
+            } while (paginationToken && resultCount < maxResults);
+            return {
+                data: totalData,
+                includes: totalIncludes,
+            };
+        },
+        async addUserToList({ listId, ...args }) {
+            return this._httpRequest({
+                method: "POST",
+                url: `/lists/${listId}/members`,
+                ...args,
+            });
+        },
+        async createTweet(args) {
+            return this._httpRequest({
+                method: "POST",
+                url: "/tweets",
+                ...args,
+            });
+        },
+        async deleteTweet({ tweetId, ...args }) {
+            return this._httpRequest({
+                method: "DELETE",
+                url: `/tweets/${tweetId}`,
+                ...args,
+            });
+        },
+        async followUser(args) {
+            const id = await this.getAuthenticatedUserId();
+            return this._httpRequest({
+                method: "POST",
+                url: `/users/${id}/following`,
+                ...args,
+            });
+        },
+        async getListTweets({ listId, ...args }) {
+            return this._paginatedRequest({
+                url: `/lists/${listId}/tweets`,
+                ...args,
+            });
+        },
+        async getTweet({ tweetId, ...args }) {
+            return this._httpRequest({
+                url: `/tweets/${tweetId}`,
+                ...args,
+            });
+        },
+        async getAuthenticatedUserId() {
+            const response = await this._httpRequest({
+                url: "/users/me",
+            });
+            return response.data.id;
+        },
+        async getUserLikedTweets({ userId, ...args }) {
+            return this._paginatedRequest({
+                url: `/users/${userId}/liked_tweets`,
+                ...args,
+            });
+        },
+        async getUserOwnedLists({ userId, ...args }) {
+            return this._httpRequest({
+                url: `/users/${userId}/owned_lists`,
+                ...args,
+            });
+        },
+        async getUserFollowedLists({ userId, ...args }) {
+            return this._paginatedRequest({
+                url: `/users/${userId}/followed_lists`,
+                ...args,
+            });
+        },
+        async getUserMentions({ userId, ...args }) {
+            return this._paginatedRequest({
+                url: `/users/${userId}/mentions`,
+                ...args,
+            });
+        },
+        async getUserTweets({ userId, ...args }) {
+            return this._paginatedRequest({
+                url: `/users/${userId}/tweets`,
+                ...args,
+            });
+        },
+        async getUserByUsername(username) {
+            return this._httpRequest({
+                url: `/users/by/username/${username}`,
+            });
+        },
+        async getUser({ userId, ...args }) {
+            return this._httpRequest({
+                url: `/users/${userId}`,
+                ...args,
+            });
+        },
+        async likeTweet(args) {
+            const id = await this.getAuthenticatedUserId();
+            return this._httpRequest({
+                method: "POST",
+                url: `/users/${id}/likes`,
+                ...args,
+            });
+        },
+        async getUserFollowers({ userId, ...args }) {
+            return this._paginatedRequest({
+                url: `/users/${userId}/followers`,
+                ...args,
+            });
+        },
+        async getUserFollowing({ userId, ...args }) {
+            return this._paginatedRequest({
+                url: `/users/${userId}/following`,
+                ...args,
+            });
+        },
+        async retweet(args) {
+            const id = await this.getAuthenticatedUserId();
+            return this._httpRequest({
+                method: "POST",
+                url: `/users/${id}/retweets`,
+                ...args,
+            });
+        },
+        async searchTweets(args) {
+            return this._paginatedRequest({
+                url: "/tweets/search/recent",
+                ...args,
+            });
+        },
+        async unfollowUser({ userId, ...args }) {
+            const id = await this.getAuthenticatedUserId();
+            return this._httpRequest({
+                method: "DELETE",
+                url: `/users/${id}/following/${userId}`,
+                ...args,
+            });
+        },
+        async unlikeTweet({ tweetId, ...args }) {
+            const id = await this.getAuthenticatedUserId();
+            return this._httpRequest({
+                method: "DELETE",
+                url: `/users/${id}/likes/${tweetId}`,
+                ...args,
+            });
+        },
+    },
+});

package/dist/common/dataFields.d.ts

@@ -0,0 +1,6 @@
+export declare const LIST_FIELD_OPTIONS: string[];
+export declare const MEDIA_FIELD_OPTIONS: string[];
+export declare const PLACE_FIELD_OPTIONS: string[];
+export declare const POLL_FIELD_OPTIONS: string[];
+export declare const TWEET_FIELD_OPTIONS: string[];
+export declare const USER_FIELD_OPTIONS: string[];

package/dist/common/dataFields.mjs

@@ -0,0 +1,80 @@
+export const LIST_FIELD_OPTIONS = [
+    "created_at",
+    "follower_count",
+    "member_count",
+    "private",
+    "description",
+    "owner_id",
+];
+export const MEDIA_FIELD_OPTIONS = [
+    "duration_ms",
+    "height",
+    "media_key",
+    "preview_image_url",
+    "type",
+    "url",
+    "width",
+    "public_metrics",
+    "non_public_metrics",
+    "organic_metrics",
+    "promoted_metrics",
+    "alt_text",
+    "variants",
+];
+export const PLACE_FIELD_OPTIONS = [
+    "contained_within",
+    "country",
+    "country_code",
+    "full_name",
+    "geo",
+    "id",
+    "name",
+    "place_type",
+];
+export const POLL_FIELD_OPTIONS = [
+    "duration_minutes",
+    "end_datetime",
+    "id",
+    "options",
+    "voting_status",
+];
+export const TWEET_FIELD_OPTIONS = [
+    "attachments",
+    "author_id",
+    "context_annotations",
+    "conversation_id",
+    "created_at",
+    "edit_controls",
+    "entities",
+    "geo",
+    "id",
+    "in_reply_to_user_id",
+    "lang",
+    "non_public_metrics",
+    "public_metrics",
+    "organic_metrics",
+    "promoted_metrics",
+    "possibly_sensitive",
+    "referenced_tweets",
+    "reply_settings",
+    "source",
+    "text",
+    "withheld",
+];
+export const USER_FIELD_OPTIONS = [
+    "created_at",
+    "description",
+    "entities",
+    "id",
+    "location",
+    "name",
+    "pinned_tweet_id",
+    "profile_image_url",
+    "protected",
+    "public_metrics",
+    "url",
+    "username",
+    "verified",
+    "verified_type",
+    "withheld",
+];

package/dist/common/expansions.d.ts

@@ -0,0 +1,3 @@
+export declare const LIST_EXPANSION_OPTIONS: string[];
+export declare const TWEET_EXPANSION_OPTIONS: string[];
+export declare const USER_EXPANSION_OPTIONS: string[];

package/dist/common/expansions.mjs

@@ -0,0 +1,17 @@
+export const LIST_EXPANSION_OPTIONS = [
+    "owner_id",
+];
+export const TWEET_EXPANSION_OPTIONS = [
+    "attachments.poll_ids",
+    "attachments.media_keys",
+    "author_id",
+    "edit_history_tweet_ids",
+    "entities.mentions.username",
+    "geo.place_id",
+    "in_reply_to_user_id",
+    "referenced_tweets.id",
+    "referenced_tweets.id.author_id",
+];
+export const USER_EXPANSION_OPTIONS = [
+    "pinned_tweet_id",
+];

package/dist/common/methods.d.ts

@@ -0,0 +1,20 @@
+export declare function getUserId(): Promise<string>;
+export declare function getMultiItemSummary(name: string, length: number): string;
+export declare function getListFields(): {
+    expansions: string;
+    "list.fields": string;
+    "user.fields": string;
+};
+export declare function getTweetFields(): {
+    expansions: string;
+    "media.fields": string;
+    "place.fields": string;
+    "poll.fields": string;
+    "tweet.fields": string;
+    "user.fields": string;
+};
+export declare function getUserFields(): {
+    expansions: string;
+    "tweet.fields": string;
+    "user.fields": string;
+};

package/dist/common/methods.mjs

@@ -0,0 +1,48 @@
+import { ConfigurationError } from "@pipedream/platform";
+export async function getUserId() {
+    let { userNameOrId: id } = this;
+    if (id === "me" || id === undefined) {
+        id = await this.app.getAuthenticatedUserId();
+    }
+    else if (id.startsWith("@")) {
+        const userData = await this.app.getUserByUsername(id.slice(1));
+        id = userData?.data?.id;
+        if (!id)
+            throw new ConfigurationError("**User not found!** Check the `User Name or ID` prop.");
+    }
+    return id;
+}
+export function getMultiItemSummary(name, length) {
+    return length
+        ? `Successfully obtained ${length} ${name}${length === 1
+            ? ""
+            : "s"}`
+        : `No ${name}s were found`;
+}
+export function getListFields() {
+    const { expansions, listFields, userFields, } = this;
+    return {
+        "expansions": expansions?.join(),
+        "list.fields": listFields?.join(),
+        "user.fields": userFields?.join(),
+    };
+}
+export function getTweetFields() {
+    const { expansions, mediaFields, placeFields, pollFields, tweetFields, userFields, } = this;
+    return {
+        "expansions": expansions?.join(),
+        "media.fields": mediaFields?.join(),
+        "place.fields": placeFields?.join(),
+        "poll.fields": pollFields?.join(),
+        "tweet.fields": tweetFields?.join(),
+        "user.fields": userFields?.join(),
+    };
+}
+export function getUserFields() {
+    const { expansions, tweetFields, userFields, } = this;
+    return {
+        "expansions": expansions?.join(),
+        "tweet.fields": tweetFields?.join(),
+        "user.fields": userFields?.join(),
+    };
+}