nodejs-insta-private-api-mqt 1.3.70

package/dist/repositories/location.repository.js

@@ -0,0 +1,84 @@
+const Repository = require('../core/repository');
+
+class LocationRepository extends Repository {
+  async info(locationId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/locations/${locationId}/info/`,
+    });
+    
+    return response.body;
+  }
+
+  async search(query, lat, lng) {
+    const qs = {
+      search_query: query,
+      rank_token: this.client.state.uuid,
+    };
+
+    if (lat && lng) {
+      qs.latitude = lat;
+      qs.longitude = lng;
+    }
+
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/location_search/',
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async searchByCoordinates(lat, lng) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/location_search/',
+      qs: {
+        latitude: lat,
+        longitude: lng,
+        rank_token: this.client.state.uuid,
+      }
+    });
+    
+    return response.body;
+  }
+
+  async getFeed(locationId, maxId = null) {
+    const qs = {
+      rank_token: this.client.state.uuid
+    };
+    
+    if (maxId) {
+      qs.max_id = maxId;
+    }
+
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/feed/location/${locationId}/`,
+      qs
+    });
+    
+    return response.body;
+  }
+
+  async getStories(locationId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/locations/${locationId}/story/`,
+    });
+    
+    return response.body;
+  }
+
+  async getRelated(locationId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/locations/${locationId}/related/`,
+    });
+    
+    return response.body;
+  }
+}
+
+module.exports = LocationRepository;

package/dist/repositories/media.repository.js

@@ -0,0 +1,395 @@
+const Repository = require('../core/repository');
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+class MediaRepository extends Repository {
+  async info(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/info/`,
+      method: 'GET',
+    });
+    return response.body;
+  }
+
+  async like(mediaId, moduleInfo = { module_name: 'feed_timeline' }) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/like/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        media_id: mediaId,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        radio_type: this.client.state.radioType,
+        module_name: moduleInfo.module_name,
+      }),
+    });
+    return response.body;
+  }
+
+  async unlike(mediaId, moduleInfo = { module_name: 'feed_timeline' }) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/unlike/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        media_id: mediaId,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        radio_type: this.client.state.radioType,
+        module_name: moduleInfo.module_name,
+      }),
+    });
+    return response.body;
+  }
+
+  async comment(mediaId, commentText) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        media_id: mediaId,
+        comment_text: commentText,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        radio_type: this.client.state.radioType,
+        module_name: 'feed_timeline',
+      }),
+    });
+    return response.body;
+  }
+
+  async deleteComment(mediaId, commentId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/${commentId}/delete/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async delete(mediaId, mediaType = 'PHOTO') {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/delete/`,
+      method: 'POST',
+      qs: { media_type: mediaType },
+      form: this.client.request.sign({
+        igtv_feed_preview: false,
+        media_id: mediaId,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async edit(mediaId, captionText, options = {}) {
+    const { usertags, location } = options;
+    const data = {
+      igtv_feed_preview: false,
+      media_id: mediaId,
+      _uid: this.client.state.cookieUserId,
+      _uuid: this.client.state.uuid,
+      caption_text: captionText,
+    };
+    if (usertags) data.usertags = JSON.stringify({ in: usertags });
+    if (location) {
+      data.location = JSON.stringify(location);
+    }
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/edit_media/`,
+      method: 'POST',
+      form: this.client.request.sign(data),
+    });
+    return response.body;
+  }
+
+  async seen(reels) {
+    const response = await this.client.request.send({
+      url: '/api/v1/media/seen/',
+      method: 'POST',
+      form: this.client.request.sign({
+        reels: JSON.stringify(reels),
+        live_vods: JSON.stringify([]),
+        nf_token: '',
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        container_module: 'feed_short_url',
+      }),
+    });
+    return response.body;
+  }
+
+  async likers(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/likers/`,
+      method: 'GET',
+    });
+    return response.body;
+  }
+
+  async comments(mediaId, maxId = null, amount = 20) {
+    const allComments = [];
+    let nextMaxId = maxId;
+    while (allComments.length < amount) {
+      const qs = {};
+      if (nextMaxId) qs.max_id = nextMaxId;
+      const response = await this.client.request.send({
+        url: `/api/v1/media/${mediaId}/comments/`,
+        method: 'GET',
+        qs,
+      });
+      const body = response.body;
+      allComments.push(...(body.comments || []));
+      if (!body.has_more_comments || !body.next_max_id) break;
+      nextMaxId = body.next_max_id;
+    }
+    return allComments.slice(0, amount);
+  }
+
+  async replyToComment(mediaId, commentId, replyText) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        media_id: mediaId,
+        comment_text: replyText,
+        replied_to_comment_id: commentId,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+        radio_type: this.client.state.radioType,
+      }),
+    });
+    return response.body;
+  }
+
+  async likeComment(mediaId, commentId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/${commentId}/comment_like/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async unlikeComment(mediaId, commentId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/${commentId}/comment_unlike/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async pinComment(mediaId, commentId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/${commentId}/pin_comment/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async unpinComment(mediaId, commentId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/${commentId}/unpin_comment/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async bulkDeleteComments(mediaId, commentIds) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comment/bulk_delete/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        comment_ids_to_delete: Array.isArray(commentIds) ? commentIds.join(',') : commentIds,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async save(mediaId, collectionId = null) {
+    const form = {
+      _uid: this.client.state.cookieUserId,
+      _uuid: this.client.state.uuid,
+    };
+    if (collectionId) form.added_collection_ids = JSON.stringify([collectionId]);
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/save/`,
+      method: 'POST',
+      form: this.client.request.sign(form),
+    });
+    return response.body;
+  }
+
+  async unsave(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/unsave/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async archive(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/only_me/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        media_id: mediaId,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async unarchive(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/undo_only_me/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        media_id: mediaId,
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async disableComments(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/disable_comments/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async enableComments(mediaId) {
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/enable_comments/`,
+      method: 'POST',
+      form: this.client.request.sign({
+        _uid: this.client.state.cookieUserId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async commentThreadComments(mediaId, commentId, maxId = null) {
+    const qs = {};
+    if (maxId) qs.max_id = maxId;
+    const response = await this.client.request.send({
+      url: `/api/v1/media/${mediaId}/comments/${commentId}/inline_child_comments/`,
+      method: 'GET',
+      qs,
+    });
+    return response.body;
+  }
+
+  async oembed(url) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/oembed/',
+      qs: { url },
+    });
+    return response.body;
+  }
+
+  async downloadByUrl(url) {
+    const axios = require('axios');
+    const response = await axios.get(url, { responseType: 'arraybuffer' });
+    return Buffer.from(response.data);
+  }
+
+  async downloadPhoto(mediaPk) {
+    const result = await this.info(mediaPk);
+    const items = result.items || [result];
+    const item = items[0] || result;
+    const candidates = item.image_versions2?.candidates || [];
+    if (!candidates.length) throw new Error('No image candidates found');
+    return this.downloadByUrl(candidates[0].url);
+  }
+
+  async downloadVideo(mediaPk) {
+    const result = await this.info(mediaPk);
+    const items = result.items || [result];
+    const item = items[0] || result;
+    const videoVersions = item.video_versions || [];
+    if (!videoVersions.length) throw new Error('No video versions found');
+    return this.downloadByUrl(videoVersions[0].url);
+  }
+
+  static mediaPkFromCode(code) {
+    let pk = BigInt(0);
+    for (let i = 0; i < Math.min(code.length, 11); i++) {
+      const idx = ALPHABET.indexOf(code[i]);
+      if (idx === -1) continue;
+      pk = pk * BigInt(64) + BigInt(idx);
+    }
+    return pk.toString();
+  }
+
+  static mediaCodeFromPk(pk) {
+    let id = BigInt(pk);
+    let code = '';
+    while (id > BigInt(0)) {
+      const remainder = Number(id % BigInt(64));
+      code = ALPHABET[remainder] + code;
+      id = id / BigInt(64);
+    }
+    return code;
+  }
+
+  static mediaPkFromUrl(url) {
+    try {
+      const parsed = new URL(url);
+      const parts = parsed.pathname.split('/').filter(p => p.length > 0);
+      const code = parts[parts.length - 1];
+      return MediaRepository.mediaPkFromCode(code.substring(0, 11));
+    } catch {
+      return null;
+    }
+  }
+
+  mediaId(mediaPk, userId) {
+    return `${mediaPk}_${userId}`;
+  }
+
+  mediaPk(mediaId) {
+    return String(mediaId).split('_')[0];
+  }
+
+  async getUser(mediaPk) {
+    const result = await this.info(mediaPk);
+    const items = result.items || [result];
+    return (items[0] || result).user;
+  }
+}
+
+module.exports = MediaRepository;

package/dist/repositories/multiple-accounts.repository.js

@@ -0,0 +1,41 @@
+const Repository = require('../core/repository');
+
+class MultipleAccountsRepository extends Repository {
+  async getFeaturedAccounts() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/multiple_accounts/get_featured_accounts/',
+    });
+    return response.body;
+  }
+
+  async getAccountFamily() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/multiple_accounts/get_account_family/',
+    });
+    return response.body;
+  }
+
+  async getAccountInfo() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/multiple_accounts/get_account_info/',
+    });
+    return response.body;
+  }
+
+  async switchAccount(userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/multiple_accounts/switch_account/',
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    return response.body;
+  }
+}
+
+module.exports = MultipleAccountsRepository;

package/dist/repositories/news.repository.js

@@ -0,0 +1,35 @@
+const Repository = require('../core/repository');
+
+class NewsRepository extends Repository {
+  async inbox() {
+    const response = await this.client.request.send({
+      url: '/api/v1/news/inbox/',
+      method: 'GET',
+    });
+    return response.body;
+  }
+
+  async getFollowRequests(maxId = null) {
+    const qs = {};
+    if (maxId) qs.max_id = maxId;
+    const response = await this.client.request.send({
+      url: '/api/v1/news/inbox/',
+      method: 'GET',
+      qs: { ...qs, filters: 'follow_requests' },
+    });
+    return response.body;
+  }
+
+  async markAsSeen(timestamps = {}) {
+    const response = await this.client.request.send({
+      url: '/api/v1/news/inbox_seen/',
+      method: 'POST',
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+}
+
+module.exports = NewsRepository;

package/dist/repositories/note.repository.js

@@ -0,0 +1,57 @@
+const Repository = require('../core/repository');
+
+class NoteRepository extends Repository {
+  async getNotes() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/notes/get_notes/',
+    });
+    return response.body;
+  }
+
+  async createNote(text, audience = 0) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/notes/create_note/',
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        text,
+        audience,
+      }),
+    });
+    return response.body;
+  }
+
+  async deleteNote(noteId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/notes/delete_note/${noteId}/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        id: noteId,
+      }),
+    });
+    return response.body;
+  }
+
+  async lastSeenUpdateNote() {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/notes/last_seen_update/',
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async getNotesFollowing() {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: '/api/v1/notes/following_notes/',
+    });
+    return response.body;
+  }
+}
+
+module.exports = NoteRepository;

package/dist/repositories/notification.repository.js

@@ -0,0 +1,79 @@
+const Repository = require('../core/repository');
+
+const MUTE_ALL_VALUES = ['cancel', '15_minutes', '1_hour', '2_hour', '4_hour', '8_hour'];
+const SETTING_VALUES = ['off', 'following_only', 'everyone'];
+
+class NotificationRepository extends Repository {
+  async changeSettings(contentType, settingValue) {
+    let userId;
+    try { userId = this.client.state.cookieUserId; } catch { userId = '0'; }
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/notifications/change_notification_settings/',
+      form: this.client.request.sign({
+        content_type: contentType,
+        setting_value: settingValue,
+        _uid: userId,
+        _uuid: this.client.state.uuid,
+      }),
+    });
+    return response.body;
+  }
+
+  async muteAll(settingValue = '8_hour') {
+    if (!MUTE_ALL_VALUES.includes(settingValue)) {
+      throw new Error(`Unsupported mute value: ${settingValue}. Must be one of: ${MUTE_ALL_VALUES.join(', ')}`);
+    }
+    return this.changeSettings('mute_all', settingValue);
+  }
+
+  async likes(settingValue = 'off') { return this._assertAndSet('likes', settingValue); }
+  async likeAndCommentOnPhotoUserTagged(v = 'off') { return this._assertAndSet('like_and_comment_on_photo_user_tagged', v); }
+  async userTagged(v = 'off') { return this._assertAndSet('user_tagged', v); }
+  async comments(v = 'off') { return this._assertAndSet('comments', v); }
+  async commentLikes(v = 'off') { return this._assertAndSet('comment_likes', v); }
+  async firstPost(v = 'off') { return this._assertAndSet('first_post', v); }
+  async newFollower(v = 'off') { return this._assertAndSet('new_follower', v); }
+  async followRequestAccepted(v = 'off') { return this._assertAndSet('follow_request_accepted', v); }
+  async connection(v = 'off') { return this._assertAndSet('connection', v); }
+  async taggedInBio(v = 'off') { return this._assertAndSet('tagged_in_bio', v); }
+  async pendingDirectShare(v = 'off') { return this._assertAndSet('pending_direct_share', v); }
+  async directShareActivity(v = 'off') { return this._assertAndSet('direct_share_activity', v); }
+  async directGroupRequests(v = 'off') { return this._assertAndSet('direct_group_requests', v); }
+  async videoCall(v = 'off') { return this._assertAndSet('video_call', v); }
+  async rooms(v = 'off') { return this._assertAndSet('rooms', v); }
+  async liveBroadcast(v = 'off') { return this._assertAndSet('live_broadcast', v); }
+  async felixUploadResult(v = 'off') { return this._assertAndSet('felix_upload_result', v); }
+  async viewCount(v = 'off') { return this._assertAndSet('view_count', v); }
+  async fundraiserCreator(v = 'off') { return this._assertAndSet('fundraiser_creator', v); }
+  async fundraiserSupporter(v = 'off') { return this._assertAndSet('fundraiser_supporter', v); }
+  async reminders(v = 'off') { return this._assertAndSet('reminders', v); }
+  async announcements(v = 'off') { return this._assertAndSet('announcements', v); }
+  async reportUpdated(v = 'off') { return this._assertAndSet('report_updated', v); }
+  async login(v = 'off') { return this._assertAndSet('login_notification', v); }
+
+  async disableAll() {
+    const methods = [
+      'likes', 'likeAndCommentOnPhotoUserTagged', 'userTagged', 'comments',
+      'commentLikes', 'firstPost', 'newFollower', 'followRequestAccepted',
+      'connection', 'taggedInBio', 'pendingDirectShare', 'directShareActivity',
+      'directGroupRequests', 'videoCall', 'rooms', 'liveBroadcast',
+      'felixUploadResult', 'viewCount', 'fundraiserCreator', 'fundraiserSupporter',
+      'reminders', 'announcements', 'reportUpdated', 'login',
+    ];
+    const results = [];
+    for (const method of methods) {
+      results.push(await this[method]('off'));
+    }
+    return results.every(r => r?.status === 'ok');
+  }
+
+  _assertAndSet(contentType, settingValue) {
+    if (!SETTING_VALUES.includes(settingValue)) {
+      throw new Error(`Unsupported setting value: ${settingValue}. Must be one of: ${SETTING_VALUES.join(', ')}`);
+    }
+    return this.changeSettings(contentType, settingValue);
+  }
+}
+
+module.exports = NotificationRepository;