zotan/megalodon
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Remove mastodon and pleroma backend support

Browse source
This commit is contained in:
Laura Hausmann 2023-07-02 18:34:30 +02:00
parent 554e02dd31
commit 8958bd1b6e
Signed by: zotan
GPG key ID: D044E84C5BE01605
92 changed files with 1 additions and 8847 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
megalodon/src/index.ts
View file

@ -3,8 +3,6 @@ import OAuth from './oauth'
import { isCancel, RequestCanceledError } from './cancel'
import { ProxyConfig } from './proxy_config'
import generator, { detector, MegalodonInterface, WebSocketInterface } from './megalodon'
import Mastodon from './mastodon'
import Pleroma from './pleroma'
import Misskey from './misskey'
import Entity from './entity'
import NotificationType from './notification'
@ -22,8 +20,6 @@ export {
WebSocketInterface,
NotificationType,
FilterContext,
Mastodon,
Pleroma,
Misskey,
Entity,
Converter

2309
megalodon/src/mastodon.ts
View file

File diff suppressed because it is too large Load diff

650
megalodon/src/mastodon/api_client.ts
View file

@ -1,650 +0,0 @@
import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
import objectAssignDeep from 'object-assign-deep'
import WebSocket from './web_socket'
import Response from '../response'
import { RequestCanceledError } from '../cancel'
import proxyAgent, { ProxyConfig } from '../proxy_config'
import { NO_REDIRECT, DEFAULT_SCOPE, DEFAULT_UA } from '../default'
import MastodonEntity from './entity'
import MegalodonEntity from '../entity'
import NotificationType from '../notification'
import MastodonNotificationType from './notification'
namespace MastodonAPI {
/**
* Interface
*/
export interface Interface {
get<T = any>(path: string, params?: any, headers?: { [key: string]: string }, pathIsFullyQualified?: boolean): Promise<Response<T>>
put<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
putForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
patch<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
patchForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
post<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
postForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
del<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
cancel(): void
socket(path: string, stream: string, params?: string): WebSocket
}
/**
* Mastodon API client.
*
* Using axios for request, you will handle promises.
*/
export class Client implements Interface {
static DEFAULT_SCOPE = DEFAULT_SCOPE
static DEFAULT_URL = 'https://mastodon.social'
static NO_REDIRECT = NO_REDIRECT
private accessToken: string | null
private baseUrl: string
private userAgent: string
private abortController: AbortController
private proxyConfig: ProxyConfig | false = false
/**
* @param baseUrl hostname or base URL
* @param accessToken access token from OAuth2 authorization
* @param userAgent UserAgent is specified in header on request.
* @param proxyConfig Proxy setting, or set false if don't use proxy.
*/
constructor(
baseUrl: string,
accessToken: string | null = null,
userAgent: string = DEFAULT_UA,
proxyConfig: ProxyConfig | false = false
) {
this.accessToken = accessToken
this.baseUrl = baseUrl
this.userAgent = userAgent
this.proxyConfig = proxyConfig
this.abortController = new AbortController()
axios.defaults.signal = this.abortController.signal
}
/**
* GET request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Query parameters
* @param headers Request header object
*/
public async get<T>(
path: string,
params = {},
headers: { [key: string]: string } = {},
pathIsFullyQualified = false
): Promise<Response<T>> {
let options: AxiosRequestConfig = {
params: params,
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.get<T>((pathIsFullyQualified ? '' : this.baseUrl) + path, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PUT request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async put<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.put<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PUT request to mastodon REST API for multipart.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async putForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.putForm<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PATCH request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async patch<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.patch<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PATCH request to mastodon REST API for multipart.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async patchForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.patchForm<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* POST request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data
* @param headers Request header object
*/
public async post<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios.post<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* POST request to mastodon REST API for multipart.
* @param path relative path from baseUrl
* @param params Form data
* @param headers Request header object
*/
public async postForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios.postForm<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* DELETE request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data
* @param headers Request header object
*/
public async del<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
data: params,
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.delete(this.baseUrl + path, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* Cancel all requests in this instance.
* @returns void
*/
public cancel(): void {
return this.abortController.abort()
}
/**
* Get connection and receive websocket connection for Pleroma API.
*
* @param path relative path from baseUrl: normally it is `/streaming`.
* @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
* @returns WebSocket, which inherits from EventEmitter
*/
public socket(path: string, stream: string, params?: string): WebSocket {
if (!this.accessToken) {
throw new Error('accessToken is required')
}
const url = this.baseUrl + path
const streaming = new WebSocket(url, stream, params, this.accessToken, this.userAgent, this.proxyConfig)
process.nextTick(() => {
streaming.start()
})
return streaming
}
}
export namespace Entity {
export type Account = MastodonEntity.Account
export type Activity = MastodonEntity.Activity
export type Announcement = MastodonEntity.Announcement
export type Application = MastodonEntity.Application
export type AsyncAttachment = MegalodonEntity.AsyncAttachment
export type Attachment = MastodonEntity.Attachment
export type Card = MastodonEntity.Card
export type Context = MastodonEntity.Context
export type Conversation = MastodonEntity.Conversation
export type Emoji = MastodonEntity.Emoji
export type FeaturedTag = MastodonEntity.FeaturedTag
export type Field = MastodonEntity.Field
export type Filter = MastodonEntity.Filter
export type History = MastodonEntity.History
export type IdentityProof = MastodonEntity.IdentityProof
export type Instance = MastodonEntity.Instance
export type List = MastodonEntity.List
export type Marker = MastodonEntity.Marker
export type Mention = MastodonEntity.Mention
export type Notification = MastodonEntity.Notification
export type Poll = MastodonEntity.Poll
export type PollOption = MastodonEntity.PollOption
export type Preferences = MastodonEntity.Preferences
export type PushSubscription = MastodonEntity.PushSubscription
export type Relationship = MastodonEntity.Relationship
export type Reaction = MastodonEntity.Reaction
export type Report = MastodonEntity.Report
export type Results = MastodonEntity.Results
export type ScheduledStatus = MastodonEntity.ScheduledStatus
export type Source = MastodonEntity.Source
export type Stats = MastodonEntity.Stats
export type Status = MastodonEntity.Status
export type StatusParams = MastodonEntity.StatusParams
export type Tag = MastodonEntity.Tag
export type Token = MastodonEntity.Token
export type URLs = MastodonEntity.URLs
}
export namespace Converter {
export const encodeNotificationType = (t: MegalodonEntity.NotificationType): MastodonEntity.NotificationType => {
switch (t) {
case NotificationType.Follow:
return MastodonNotificationType.Follow
case NotificationType.Favourite:
return MastodonNotificationType.Favourite
case NotificationType.Reblog:
return MastodonNotificationType.Reblog
case NotificationType.Mention:
return MastodonNotificationType.Mention
case NotificationType.FollowRequest:
return MastodonNotificationType.FollowRequest
case NotificationType.Status:
return MastodonNotificationType.Status
case NotificationType.PollExpired:
return MastodonNotificationType.Poll
default:
return t
}
}
export const decodeNotificationType = (t: MastodonEntity.NotificationType): MegalodonEntity.NotificationType => {
switch (t) {
case MastodonNotificationType.Follow:
return NotificationType.Follow
case MastodonNotificationType.Favourite:
return NotificationType.Favourite
case MastodonNotificationType.Mention:
return NotificationType.Mention
case MastodonNotificationType.Reblog:
return NotificationType.Reblog
case MastodonNotificationType.FollowRequest:
return NotificationType.FollowRequest
case MastodonNotificationType.Status:
return NotificationType.Status
case MastodonNotificationType.Poll:
return NotificationType.PollExpired
default:
return t
}
}
export const account = (a: Entity.Account): MegalodonEntity.Account => a
export const activity = (a: Entity.Activity): MegalodonEntity.Activity => a
export const announcement = (a: Entity.Announcement): MegalodonEntity.Announcement => ({
...a,
reactions: a.reactions.map(r => reaction(r))
})
export const application = (a: Entity.Application): MegalodonEntity.Application => a
export const attachment = (a: Entity.Attachment): MegalodonEntity.Attachment => a
export const async_attachment = (a: Entity.AsyncAttachment) => {
if (a.url) {
return {
id: a.id,
type: a.type,
url: a.url!,
remote_url: a.remote_url,
preview_url: a.preview_url,
text_url: a.text_url,
meta: a.meta,
description: a.description,
blurhash: a.blurhash
} as MegalodonEntity.Attachment
} else {
return a as MegalodonEntity.AsyncAttachment
}
}
export const card = (c: Entity.Card): MegalodonEntity.Card => c
export const context = (c: Entity.Context): MegalodonEntity.Context => ({
ancestors: c.ancestors.map(a => status(a)),
descendants: c.descendants.map(d => status(d))
})
export const conversation = (c: Entity.Conversation): MegalodonEntity.Conversation => ({
id: c.id,
accounts: c.accounts.map(a => account(a)),
last_status: c.last_status ? status(c.last_status) : null,
unread: c.unread
})
export const emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => e
export const featured_tag = (e: Entity.FeaturedTag): MegalodonEntity.FeaturedTag => e
export const field = (f: Entity.Field): MegalodonEntity.Field => f
export const filter = (f: Entity.Filter): MegalodonEntity.Filter => f
export const history = (h: Entity.History): MegalodonEntity.History => h
export const identity_proof = (i: Entity.IdentityProof): MegalodonEntity.IdentityProof => i
export const instance = (i: Entity.Instance): MegalodonEntity.Instance => i
export const list = (l: Entity.List): MegalodonEntity.List => l
export const marker = (m: Entity.Marker): MegalodonEntity.Marker => m
export const mention = (m: Entity.Mention): MegalodonEntity.Mention => m
export const notification = (n: Entity.Notification): MegalodonEntity.Notification => {
if (n.status) {
return {
account: account(n.account),
created_at: n.created_at,
id: n.id,
status: status(n.status),
type: decodeNotificationType(n.type)
}
} else {
return {
account: account(n.account),
created_at: n.created_at,
id: n.id,
type: decodeNotificationType(n.type)
}
}
}
export const poll = (p: Entity.Poll): MegalodonEntity.Poll => p
export const poll_option = (p: Entity.PollOption): MegalodonEntity.PollOption => p
export const preferences = (p: Entity.Preferences): MegalodonEntity.Preferences => p
export const push_subscription = (p: Entity.PushSubscription): MegalodonEntity.PushSubscription => p
export const relationship = (r: Entity.Relationship): MegalodonEntity.Relationship => r
export const reaction = (r: Entity.Reaction): MegalodonEntity.Reaction => ({
count: r.count,
me: r.me ?? false,
name: r.name,
url: r.url,
})
export const report = (r: Entity.Report): MegalodonEntity.Report => r
export const results = (r: Entity.Results): MegalodonEntity.Results => ({
accounts: r.accounts.map(a => account(a)),
statuses: r.statuses.map(s => status(s)),
hashtags: r.hashtags.map(h => tag(h))
})
export const scheduled_status = (s: Entity.ScheduledStatus): MegalodonEntity.ScheduledStatus => s
export const source = (s: Entity.Source): MegalodonEntity.Source => s
export const stats = (s: Entity.Stats): MegalodonEntity.Stats => s
export const status = (s: Entity.Status): MegalodonEntity.Status => ({
id: s.id,
uri: s.uri,
url: s.url,
account: account(s.account),
in_reply_to_id: s.in_reply_to_id,
in_reply_to_account_id: s.in_reply_to_account_id,
reblog: s.reblog ? status(s.reblog) : s.quote ? status(s.quote) : null,
content: s.content,
plain_content: null,
created_at: s.created_at,
emojis: s.emojis.map(e => emoji(e)),
replies_count: s.replies_count,
reblogs_count: s.reblogs_count,
favourites_count: s.favourites_count,
reblogged: s.reblogged,
favourited: s.favourited,
muted: s.muted,
sensitive: s.sensitive,
spoiler_text: s.spoiler_text,
visibility: s.visibility,
media_attachments: s.media_attachments.map(m => attachment(m)),
mentions: s.mentions.map(m => mention(m)),
tags: s.tags.map(t => tag(t)),
card: s.card ? card(s.card) : null,
poll: s.poll ? poll(s.poll) : null,
application: s.application ? application(s.application) : null,
language: s.language,
pinned: s.pinned,
emoji_reactions: [],
bookmarked: s.bookmarked ? s.bookmarked : false,
// Now quote is supported only fedibird.com.
quote: s.quote ? status(s.quote) : null
})
export const status_params = (s: Entity.StatusParams): MegalodonEntity.StatusParams => s
export const tag = (t: Entity.Tag): MegalodonEntity.Tag => t
export const token = (t: Entity.Token): MegalodonEntity.Token => t
export const urls = (u: Entity.URLs): MegalodonEntity.URLs => u
}
}
export default MastodonAPI

27
megalodon/src/mastodon/entities/account.ts
View file

@ -1,27 +0,0 @@
/// <reference path="emoji.ts" />
/// <reference path="source.ts" />
/// <reference path="field.ts" />
namespace MastodonEntity {
export type Account = {
id: string
username: string
acct: string
display_name: string
locked: boolean
created_at: string
followers_count: number
following_count: number
statuses_count: number
note: string
url: string
avatar: string
avatar_static: string
header: string
header_static: string
emojis: Array<Emoji>
moved: Account | null
fields: Array<Field>
bot: boolean | null
source?: Source
}
}

8
megalodon/src/mastodon/entities/activity.ts
View file

@ -1,8 +0,0 @@
namespace MastodonEntity {
export type Activity = {
week: string
statuses: string
logins: string
registrations: string
}
}

41
megalodon/src/mastodon/entities/announcement.ts
View file

@ -1,41 +0,0 @@
/// <reference path="tag.ts" />
/// <reference path="emoji.ts" />
namespace MastodonEntity {
export type Announcement = {
id: string
content: string
starts_at: string | null
ends_at: string | null
published: boolean
all_day: boolean
published_at: string
updated_at: string
read?: boolean
mentions: Array<AnnouncementAccount>
statuses: Array<AnnouncementStatus>
tags: Array<Tag>
emojis: Array<Emoji>
reactions: Array<Reaction>
}
export type AnnouncementAccount = {
id: string
username: string
url: string
acct: string
}
export type AnnouncementStatus = {
id: string
url: string
}
export type Reaction = {
name: string
count: number
me?: boolean
url?: string
static_url?: string
}
}

7
megalodon/src/mastodon/entities/application.ts
View file

@ -1,7 +0,0 @@
namespace MastodonEntity {
export type Application = {
name: string
website?: string | null
vapid_key?: string | null
}
}

14
megalodon/src/mastodon/entities/async_attachment.ts
View file

@ -1,14 +0,0 @@
/// <reference path="attachment.ts" />
namespace MastodonEntity {
export type AsyncAttachment = {
id: string
type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio'
url: string | null
remote_url: string | null
preview_url: string
text_url: string | null
meta: Meta | null
description: string | null
blurhash: string | null
}
}

49
megalodon/src/mastodon/entities/attachment.ts
View file

@ -1,49 +0,0 @@
namespace MastodonEntity {
export type Sub = {
// For Image, Gifv, and Video
width?: number
height?: number
size?: string
aspect?: number
// For Gifv and Video
frame_rate?: string
// For Audio, Gifv, and Video
duration?: number
bitrate?: number
}
export type Focus = {
x: number
y: number
}
export type Meta = {
original?: Sub
small?: Sub
focus?: Focus
length?: string
duration?: number
fps?: number
size?: string
width?: number
height?: number
aspect?: number
audio_encode?: string
audio_bitrate?: string
audio_channel?: string
}
export type Attachment = {
id: string
type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio'
url: string
remote_url: string | null
preview_url: string | null
text_url: string | null
meta: Meta | null
description: string | null
blurhash: string | null
}
}

16
megalodon/src/mastodon/entities/card.ts
View file

@ -1,16 +0,0 @@
namespace MastodonEntity {
export type Card = {
url: string
title: string
description: string
type: 'link' | 'photo' | 'video' | 'rich'
image?: string
author_name?: string
author_url?: string
provider_name?: string
provider_url?: string
html?: string
width?: number
height?: number
}
}

8
megalodon/src/mastodon/entities/context.ts
View file

@ -1,8 +0,0 @@
/// <reference path="status.ts" />
namespace MastodonEntity {
export type Context = {
ancestors: Array<Status>
descendants: Array<Status>
}
}

11
megalodon/src/mastodon/entities/conversation.ts
View file

@ -1,11 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="status.ts" />
namespace MastodonEntity {
export type Conversation = {
id: string
accounts: Array<Account>
last_status: Status | null
unread: boolean
}
}

9
megalodon/src/mastodon/entities/emoji.ts
View file

@ -1,9 +0,0 @@
namespace MastodonEntity {
export type Emoji = {
shortcode: string
static_url: string
url: string
visible_in_picker: boolean
category: string
}
}

8
megalodon/src/mastodon/entities/featured_tag.ts
View file

@ -1,8 +0,0 @@
namespace MastodonEntity {
export type FeaturedTag = {
id: string
name: string
statuses_count: number
last_status_at: string
}
}

7
megalodon/src/mastodon/entities/field.ts
View file

@ -1,7 +0,0 @@
namespace MastodonEntity {
export type Field = {
name: string
value: string
verified_at: string | null
}
}

12
megalodon/src/mastodon/entities/filter.ts
View file

@ -1,12 +0,0 @@
namespace MastodonEntity {
export type Filter = {
id: string
phrase: string
context: Array<FilterContext>
expires_at: string | null
irreversible: boolean
whole_word: boolean
}
export type FilterContext = string
}

7
megalodon/src/mastodon/entities/history.ts
View file

@ -1,7 +0,0 @@
namespace MastodonEntity {
export type History = {
day: string
uses: number
accounts: number
}
}

9
megalodon/src/mastodon/entities/identity_proof.ts
View file

@ -1,9 +0,0 @@
namespace MastodonEntity {
export type IdentityProof = {
provider: string
provider_username: string
updated_at: string
proof_url: string
profile_url: string
}
}

41
megalodon/src/mastodon/entities/instance.ts
View file

@ -1,41 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="urls.ts" />
/// <reference path="stats.ts" />
namespace MastodonEntity {
export type Instance = {
uri: string
title: string
description: string
email: string
version: string
thumbnail: string | null
urls: URLs
stats: Stats
languages: Array<string>
contact_account: Account | null
max_toot_chars?: number
registrations?: boolean
configuration?: {
statuses: {
max_characters: number
max_media_attachments: number
characters_reserved_per_url: number
}
media_attachments: {
supported_mime_types: Array<string>
image_size_limit: number
image_matrix_limit: number
video_size_limit: number
video_frame_limit: number
video_matrix_limit: number
}
polls: {
max_options: number
max_characters_per_option: number
min_expiration: number
max_expiration: number
}
}
}
}

6
megalodon/src/mastodon/entities/list.ts
View file

@ -1,6 +0,0 @@
namespace MastodonEntity {
export type List = {
id: string
title: string
}
}

14
megalodon/src/mastodon/entities/marker.ts
View file

@ -1,14 +0,0 @@
namespace MastodonEntity {
export type Marker = {
home: {
last_read_id: string
version: number
updated_at: string
}
notifications: {
last_read_id: string
version: number
updated_at: string
}
}
}

8
megalodon/src/mastodon/entities/mention.ts
View file

@ -1,8 +0,0 @@
namespace MastodonEntity {
export type Mention = {
id: string
username: string
url: string
acct: string
}
}

14
megalodon/src/mastodon/entities/notification.ts
View file

@ -1,14 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="status.ts" />
namespace MastodonEntity {
export type Notification = {
account: Account
created_at: string
id: string
status?: Status
type: NotificationType
}
export type NotificationType = string
}

13
megalodon/src/mastodon/entities/poll.ts
View file

@ -1,13 +0,0 @@
/// <reference path="poll_option.ts" />
namespace MastodonEntity {
export type Poll = {
id: string
expires_at: string | null
expired: boolean
multiple: boolean
votes_count: number
options: Array<PollOption>
voted: boolean
}
}

6
megalodon/src/mastodon/entities/poll_option.ts
View file

@ -1,6 +0,0 @@
namespace MastodonEntity {
export type PollOption = {
title: string
votes_count: number | null
}
}

9
megalodon/src/mastodon/entities/preferences.ts
View file

@ -1,9 +0,0 @@
namespace MastodonEntity {
export type Preferences = {
'posting:default:visibility': 'public' | 'unlisted' | 'private' | 'direct'
'posting:default:sensitive': boolean
'posting:default:language': string | null
'reading:expand:media': 'default' | 'show_all' | 'hide_all'
'reading:expand:spoilers': boolean
}
}

16
megalodon/src/mastodon/entities/push_subscription.ts
View file

@ -1,16 +0,0 @@
namespace MastodonEntity {
export type Alerts = {
follow: boolean
favourite: boolean
mention: boolean
reblog: boolean
poll: boolean
}
export type PushSubscription = {
id: string
endpoint: string
server_key: string
alerts: Alerts
}
}

18
megalodon/src/mastodon/entities/relationship.ts
View file

@ -1,18 +0,0 @@
namespace MastodonEntity {
export type Relationship = {
id: string
following: boolean
followed_by: boolean
delivery_following: boolean
blocking: boolean
blocked_by: boolean
muting: boolean
muting_notifications: boolean
requested: boolean
domain_blocking: boolean
showing_reblogs: boolean
endorsed: boolean
notifying: boolean
note: string
}
}

9
megalodon/src/mastodon/entities/report.ts
View file

@ -1,9 +0,0 @@
namespace MastodonEntity {
export type Report = {
id: string
action_taken: string
comment: string
account_id: string
status_ids: Array<string>
}
}

11
megalodon/src/mastodon/entities/results.ts
View file

@ -1,11 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="status.ts" />
/// <reference path="tag.ts" />
namespace MastodonEntity {
export type Results = {
accounts: Array<Account>
statuses: Array<Status>
hashtags: Array<Tag>
}
}

10
megalodon/src/mastodon/entities/scheduled_status.ts
View file

@ -1,10 +0,0 @@
/// <reference path="attachment.ts" />
/// <reference path="status_params.ts" />
namespace MastodonEntity {
export type ScheduledStatus = {
id: string
scheduled_at: string
params: StatusParams
media_attachments: Array<Attachment>
}
}

10
megalodon/src/mastodon/entities/source.ts
View file

@ -1,10 +0,0 @@
/// <reference path="field.ts" />
namespace MastodonEntity {
export type Source = {
privacy: string | null
sensitive: boolean | null
language: string | null
note: string
fields: Array<Field>
}
}

7
megalodon/src/mastodon/entities/stats.ts
View file

@ -1,7 +0,0 @@
namespace MastodonEntity {
export type Stats = {
user_count: number
status_count: number
domain_count: number
}
}

44
megalodon/src/mastodon/entities/status.ts
View file

@ -1,44 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="application.ts" />
/// <reference path="mention.ts" />
/// <reference path="tag.ts" />
/// <reference path="attachment.ts" />
/// <reference path="emoji.ts" />
/// <reference path="card.ts" />
/// <reference path="poll.ts" />
namespace MastodonEntity {
export type Status = {
id: string
uri: string
url: string
account: Account
in_reply_to_id: string | null
in_reply_to_account_id: string | null
reblog: Status | null
content: string
created_at: string
emojis: Emoji[]
replies_count: number
reblogs_count: number
favourites_count: number
reblogged: boolean | null
favourited: boolean | null
muted: boolean | null
sensitive: boolean
spoiler_text: string
visibility: 'public' | 'unlisted' | 'private' | 'direct'
media_attachments: Array<Attachment>
mentions: Array<Mention>
tags: Array<Tag>
card: Card | null
poll: Poll | null
application: Application | null
language: string | null
pinned: boolean | null
bookmarked?: boolean
// These parameters are unique parameters in fedibird.com for quote.
quote_id?: string
quote?: Status | null
}
}

12
megalodon/src/mastodon/entities/status_params.ts
View file

@ -1,12 +0,0 @@
namespace MastodonEntity {
export type StatusParams = {
text: string
in_reply_to_id: string | null
media_ids: Array<string> | null
sensitive: boolean | null
spoiler_text: string | null
visibility: 'public' | 'unlisted' | 'private' | 'direct'
scheduled_at: string | null
application_id: string
}
}

10
megalodon/src/mastodon/entities/tag.ts
View file

@ -1,10 +0,0 @@
/// <reference path="history.ts" />
namespace MastodonEntity {
export type Tag = {
name: string
url: string
history: Array<History> | null
following?: boolean
}
}

8
megalodon/src/mastodon/entities/token.ts
View file

@ -1,8 +0,0 @@
namespace MastodonEntity {
export type Token = {
access_token: string
token_type: string
scope: string
created_at: number
}
}

5
megalodon/src/mastodon/entities/urls.ts
View file

@ -1,5 +0,0 @@
namespace MastodonEntity {
export type URLs = {
streaming_api: string
}
}

37
megalodon/src/mastodon/entity.ts
View file

@ -1,37 +0,0 @@
/// <reference path="./entities/account.ts" />
/// <reference path="./entities/activity.ts" />
/// <reference path="./entities/announcement.ts" />
/// <reference path="./entities/application.ts" />
/// <reference path="./entities/async_attachment.ts" />
/// <reference path="./entities/attachment.ts" />
/// <reference path="./entities/card.ts" />
/// <reference path="./entities/context.ts" />
/// <reference path="./entities/conversation.ts" />
/// <reference path="./entities/emoji.ts" />
/// <reference path="./entities/featured_tag.ts" />
/// <reference path="./entities/field.ts" />
/// <reference path="./entities/filter.ts" />
/// <reference path="./entities/history.ts" />
/// <reference path="./entities/identity_proof.ts" />
/// <reference path="./entities/instance.ts" />
/// <reference path="./entities/list.ts" />
/// <reference path="./entities/marker.ts" />
/// <reference path="./entities/mention.ts" />
/// <reference path="./entities/notification.ts" />
/// <reference path="./entities/poll.ts" />
/// <reference path="./entities/poll_option.ts" />
/// <reference path="./entities/preferences.ts" />
/// <reference path="./entities/push_subscription.ts" />
/// <reference path="./entities/relationship.ts" />
/// <reference path="./entities/report.ts" />
/// <reference path="./entities/results.ts" />
/// <reference path="./entities/scheduled_status.ts" />
/// <reference path="./entities/source.ts" />
/// <reference path="./entities/stats.ts" />
/// <reference path="./entities/status.ts" />
/// <reference path="./entities/status_params.ts" />
/// <reference path="./entities/tag.ts" />
/// <reference path="./entities/token.ts" />
/// <reference path="./entities/urls.ts" />
export default MastodonEntity

13
megalodon/src/mastodon/notification.ts
View file

@ -1,13 +0,0 @@
import MastodonEntity from './entity'
namespace MastodonNotificationType {
export const Mention: MastodonEntity.NotificationType = 'mention'
export const Reblog: MastodonEntity.NotificationType = 'reblog'
export const Favourite: MastodonEntity.NotificationType = 'favourite'
export const Follow: MastodonEntity.NotificationType = 'follow'
export const Poll: MastodonEntity.NotificationType = 'poll'
export const FollowRequest: MastodonEntity.NotificationType = 'follow_request'
export const Status: MastodonEntity.NotificationType = 'status'
}
export default MastodonNotificationType

342
megalodon/src/mastodon/web_socket.ts
View file

@ -1,342 +0,0 @@
import WS from 'ws'
import dayjs, { Dayjs } from 'dayjs'
import { EventEmitter } from 'events'
import proxyAgent, { ProxyConfig } from '../proxy_config'
import { WebSocketInterface } from '../megalodon'
import MastodonAPI from './api_client'
/**
* WebSocket
* Pleroma is not support streaming. It is support websocket instead of streaming.
* So this class connect to Phoenix websocket for Pleroma.
*/
export default class WebSocket extends EventEmitter implements WebSocketInterface {
public url: string
public stream: string
public params: string | null
public parser: Parser
public headers: { [key: string]: string }
public proxyConfig: ProxyConfig | false = false
private _accessToken: string
private _reconnectInterval: number
private _reconnectMaxAttempts: number
private _reconnectCurrentAttempts: number
private _connectionClosed: boolean
private _client: WS | null
private _pongReceivedTimestamp: Dayjs
private _heartbeatInterval: number = 60000
private _pongWaiting: boolean = false
/**
* @param url Full url of websocket: e.g. https://pleroma.io/api/v1/streaming
* @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
* @param accessToken The access token.
* @param userAgent The specified User Agent.
* @param proxyConfig Proxy setting, or set false if don't use proxy.
*/
constructor(
url: string,
stream: string,
params: string | undefined,
accessToken: string,
userAgent: string,
proxyConfig: ProxyConfig | false = false
) {
super()
this.url = url
this.stream = stream
if (params === undefined) {
this.params = null
} else {
this.params = params
}
this.parser = new Parser()
this.headers = {
'User-Agent': userAgent
}
this.proxyConfig = proxyConfig
this._accessToken = accessToken
this._reconnectInterval = 10000
this._reconnectMaxAttempts = Infinity
this._reconnectCurrentAttempts = 0
this._connectionClosed = false
this._client = null
this._pongReceivedTimestamp = dayjs()
}
/**
* Start websocket connection.
*/
public start() {
this._connectionClosed = false
this._resetRetryParams()
this._startWebSocketConnection()
}
/**
* Reset connection and start new websocket connection.
*/
private _startWebSocketConnection() {
this._resetConnection()
this._setupParser()
this._client = this._connect(this.url, this.stream, this.params, this._accessToken, this.headers, this.proxyConfig)
this._bindSocket(this._client)
}
/**
* Stop current connection.
*/
public stop() {
this._connectionClosed = true
this._resetConnection()
this._resetRetryParams()
}
/**
* Clean up current connection, and listeners.
*/
private _resetConnection() {
if (this._client) {
this._client.close(1000)
this._client.removeAllListeners()
this._client = null
}
if (this.parser) {
this.parser.removeAllListeners()
}
}
/**
* Resets the parameters used in reconnect.
*/
private _resetRetryParams() {
this._reconnectCurrentAttempts = 0
}
/**
* Reconnects to the same endpoint.
*/
private _reconnect() {
setTimeout(() => {
// Skip reconnect when client is connecting.
// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L365
if (this._client && this._client.readyState === WS.CONNECTING) {
return
}
if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) {
this._reconnectCurrentAttempts++
this._clearBinding()
if (this._client) {
// In reconnect, we want to close the connection immediately,
// because recoonect is necessary when some problems occur.
this._client.terminate()
}
// Call connect methods
console.log('Reconnecting')
this._client = this._connect(this.url, this.stream, this.params, this._accessToken, this.headers, this.proxyConfig)
this._bindSocket(this._client)
}
}, this._reconnectInterval)
}
/**
* @param url Base url of streaming endpoint.
* @param stream The specified stream name.
* @param accessToken Access token.
* @param headers The specified headers.
* @param proxyConfig Proxy setting, or set false if don't use proxy.
* @return A WebSocket instance.
*/
private _connect(
url: string,
stream: string,
params: string | null,
accessToken: string,
headers: { [key: string]: string },
proxyConfig: ProxyConfig | false
): WS {
const parameter: Array<string> = [`stream=${stream}`]
if (params) {
parameter.push(params)
}
if (accessToken !== null) {
parameter.push(`access_token=${accessToken}`)
}
const requestURL: string = `${url}/?${parameter.join('&')}`
let options: WS.ClientOptions = {
headers: headers
}
if (proxyConfig) {
options = Object.assign(options, {
agent: proxyAgent(proxyConfig)
})
}
const cli: WS = new WS(requestURL, options)
return cli
}
/**
* Clear binding event for web socket client.
*/
private _clearBinding() {
if (this._client) {
this._client.removeAllListeners('close')
this._client.removeAllListeners('pong')
this._client.removeAllListeners('open')
this._client.removeAllListeners('message')
this._client.removeAllListeners('error')
}
}
/**
* Bind event for web socket client.
* @param client A WebSocket instance.
*/
private _bindSocket(client: WS) {
client.on('close', (code: number, _reason: Buffer) => {
// Refer the code: https://tools.ietf.org/html/rfc6455#section-7.4
if (code === 1000) {
this.emit('close', {})
} else {
console.log(`Closed connection with ${code}`)
// If already called close method, it does not retry.
if (!this._connectionClosed) {
this._reconnect()
}
}
})
client.on('pong', () => {
this._pongWaiting = false
this.emit('pong', {})
this._pongReceivedTimestamp = dayjs()
// It is required to anonymous function since get this scope in checkAlive.
setTimeout(() => this._checkAlive(this._pongReceivedTimestamp), this._heartbeatInterval)
})
client.on('open', () => {
this.emit('connect', {})
// Call first ping event.
setTimeout(() => {
client.ping('')
}, 10000)
})
client.on('message', (data: WS.Data, isBinary: boolean) => {
this.parser.parse(data, isBinary)
})
client.on('error', (err: Error) => {
this.emit('error', err)
})
}
/**
* Set up parser when receive message.
*/
private _setupParser() {
this.parser.on('update', (status: MastodonAPI.Entity.Status) => {
this.emit('update', MastodonAPI.Converter.status(status))
})
this.parser.on('notification', (notification: MastodonAPI.Entity.Notification) => {
this.emit('notification', MastodonAPI.Converter.notification(notification))
})
this.parser.on('delete', (id: string) => {
this.emit('delete', id)
})
this.parser.on('conversation', (conversation: MastodonAPI.Entity.Conversation) => {
this.emit('conversation', MastodonAPI.Converter.conversation(conversation))
})
this.parser.on('status_update', (status: MastodonAPI.Entity.Status) => {
this.emit('status_update', MastodonAPI.Converter.status(status))
})
this.parser.on('error', (err: Error) => {
this.emit('parser-error', err)
})
this.parser.on('heartbeat', _ => {
this.emit('heartbeat', 'heartbeat')
})
}
/**
* Call ping and wait to pong.
*/
private _checkAlive(timestamp: Dayjs) {
const now: Dayjs = dayjs()
// Block multiple calling, if multiple pong event occur.
// It the duration is less than interval, through ping.
if (now.diff(timestamp) > this._heartbeatInterval - 1000 && !this._connectionClosed) {
// Skip ping when client is connecting.
// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L289
if (this._client && this._client.readyState !== WS.CONNECTING) {
this._pongWaiting = true
this._client.ping('')
setTimeout(() => {
if (this._pongWaiting) {
this._pongWaiting = false
this._reconnect()
}
}, 10000)
}
}
}
}
/**
* Parser
* This class provides parser for websocket message.
*/
export class Parser extends EventEmitter {
/**
* @param message Message body of websocket.
*/
public parse(data: WS.Data, isBinary: boolean) {
const message = isBinary ? data : data.toString()
if (typeof message !== 'string') {
this.emit('heartbeat', {})
return
}
if (message === '') {
this.emit('heartbeat', {})
return
}
let event = ''
let payload = ''
let mes = {}
try {
const obj = JSON.parse(message)
event = obj.event
payload = obj.payload
mes = JSON.parse(payload)
} catch (err) {
// delete event does not have json object
if (event !== 'delete') {
this.emit('error', new Error(`Error parsing websocket reply: ${message}, error message: ${err}`))
return
}
}
switch (event) {
case 'update':
this.emit('update', mes as MastodonAPI.Entity.Status)
break
case 'notification':
this.emit('notification', mes as MastodonAPI.Entity.Notification)
break
case 'conversation':
this.emit('conversation', mes as MastodonAPI.Entity.Conversation)
break
case 'delete':
this.emit('delete', payload)
break
case 'status.update':
this.emit('status_update', mes as MastodonAPI.Entity.Status)
break
default:
this.emit('error', new Error(`Unknown event has received: ${message}`))
}
}
}

21
megalodon/src/megalodon.ts
View file

@ -1,8 +1,6 @@
import Response from './response'
import OAuth from './oauth'
import Pleroma from './pleroma'
import proxyAgent, { ProxyConfig } from './proxy_config'
import Mastodon from './mastodon'
import Entity from './entity'
import axios, { AxiosRequestConfig } from 'axios'
import Misskey from './misskey'
@ -1373,7 +1371,6 @@ export const detector = async (url: string, proxyConfig: ProxyConfig | false = f
/**
* Get client for each SNS according to megalodon interface.
*
* @param sns Name of your SNS, `mastodon` or `pleroma`.
* @param baseUrl hostname or base URL.
* @param accessToken access token from OAuth2 authorization
* @param userAgent UserAgent is specified in header on request.
@ -1381,26 +1378,10 @@ export const detector = async (url: string, proxyConfig: ProxyConfig | false = f
* @return Client instance for each SNS you specified.
*/
const generator = (
sns: 'mastodon' | 'pleroma' | 'misskey',
baseUrl: string,
accessToken: string | null = null,
userAgent: string | null = null,
proxyConfig: ProxyConfig | false = false
): MegalodonInterface => {
switch (sns) {
case 'pleroma': {
const pleroma = new Pleroma(baseUrl, accessToken, userAgent, proxyConfig)
return pleroma
}
case 'misskey': {
const misskey = new Misskey(baseUrl, accessToken, userAgent, proxyConfig)
return misskey
}
default: {
const mastodon = new Mastodon(baseUrl, accessToken, userAgent, proxyConfig)
return mastodon
}
}
}
): MegalodonInterface => new Misskey(baseUrl, accessToken, userAgent, proxyConfig)
export default generator

2344
megalodon/src/pleroma.ts
View file

File diff suppressed because it is too large Load diff

670
megalodon/src/pleroma/api_client.ts
View file

@ -1,670 +0,0 @@
import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
import objectAssignDeep from 'object-assign-deep'
import MegalodonEntity from '../entity'
import PleromaEntity from './entity'
import Response from '../response'
import { RequestCanceledError } from '../cancel'
import proxyAgent, { ProxyConfig } from '../proxy_config'
import { NO_REDIRECT, DEFAULT_SCOPE, DEFAULT_UA } from '../default'
import WebSocket from './web_socket'
import NotificationType from '../notification'
import PleromaNotificationType from './notification'
namespace PleromaAPI {
export namespace Entity {
export type Account = PleromaEntity.Account
export type Activity = PleromaEntity.Activity
export type Announcement = PleromaEntity.Announcement
export type Application = PleromaEntity.Application
export type AsyncAttachment = PleromaEntity.AsyncAttachment
export type Attachment = PleromaEntity.Attachment
export type Card = PleromaEntity.Card
export type Context = PleromaEntity.Context
export type Conversation = PleromaEntity.Conversation
export type Emoji = PleromaEntity.Emoji
export type FeaturedTag = PleromaEntity.FeaturedTag
export type Field = PleromaEntity.Field
export type Filter = PleromaEntity.Filter
export type History = PleromaEntity.History
export type IdentityProof = PleromaEntity.IdentityProof
export type Instance = PleromaEntity.Instance
export type List = PleromaEntity.List
export type Marker = PleromaEntity.Marker
export type Mention = PleromaEntity.Mention
export type Notification = PleromaEntity.Notification
export type Poll = PleromaEntity.Poll
export type PollOption = PleromaEntity.PollOption
export type Preferences = PleromaEntity.Preferences
export type PushSubscription = PleromaEntity.PushSubscription
export type Reaction = PleromaEntity.Reaction
export type Relationship = PleromaEntity.Relationship
export type Report = PleromaEntity.Report
export type Results = PleromaEntity.Results
export type ScheduledStatus = PleromaEntity.ScheduledStatus
export type Source = PleromaEntity.Source
export type Stats = PleromaEntity.Stats
export type Status = PleromaEntity.Status
export type StatusParams = PleromaEntity.StatusParams
export type Tag = PleromaEntity.Tag
export type Token = PleromaEntity.Token
export type URLs = PleromaEntity.URLs
}
export namespace Converter {
export const decodeNotificationType = (t: PleromaEntity.NotificationType): MegalodonEntity.NotificationType => {
switch (t) {
case PleromaNotificationType.Mention:
return NotificationType.Mention
case PleromaNotificationType.Reblog:
return NotificationType.Reblog
case PleromaNotificationType.Favourite:
return NotificationType.Favourite
case PleromaNotificationType.Follow:
return NotificationType.Follow
case PleromaNotificationType.Poll:
return NotificationType.PollExpired
case PleromaNotificationType.PleromaEmojiReaction:
return NotificationType.EmojiReaction
case PleromaNotificationType.FollowRequest:
return NotificationType.FollowRequest
default:
return t
}
}
export const encodeNotificationType = (t: MegalodonEntity.NotificationType): PleromaEntity.NotificationType => {
switch (t) {
case NotificationType.Follow:
return PleromaNotificationType.Follow
case NotificationType.Favourite:
return PleromaNotificationType.Favourite
case NotificationType.Reblog:
return PleromaNotificationType.Reblog
case NotificationType.Mention:
return PleromaNotificationType.Mention
case NotificationType.PollExpired:
return PleromaNotificationType.Poll
case NotificationType.EmojiReaction:
return PleromaNotificationType.PleromaEmojiReaction
case NotificationType.FollowRequest:
return PleromaNotificationType.FollowRequest
default:
return t
}
}
export const account = (a: Entity.Account): MegalodonEntity.Account => a
export const activity = (a: Entity.Activity): MegalodonEntity.Activity => a
export const announcement = (a: Entity.Announcement): MegalodonEntity.Announcement => a
export const application = (a: Entity.Application): MegalodonEntity.Application => a
export const attachment = (a: Entity.Attachment): MegalodonEntity.Attachment => a
export const async_attachment = (a: Entity.AsyncAttachment) => {
if (a.url) {
return {
id: a.id,
type: a.type,
url: a.url!,
remote_url: a.remote_url,
preview_url: a.preview_url,
text_url: a.text_url,
meta: a.meta,
description: a.description,
blurhash: a.blurhash
} as MegalodonEntity.Attachment
} else {
return a as MegalodonEntity.AsyncAttachment
}
}
export const card = (c: Entity.Card): MegalodonEntity.Card => c
export const context = (c: Entity.Context): MegalodonEntity.Context => ({
ancestors: c.ancestors.map(a => status(a)),
descendants: c.descendants.map(d => status(d))
})
export const conversation = (c: Entity.Conversation): MegalodonEntity.Conversation => ({
id: c.id,
accounts: c.accounts.map(a => account(a)),
last_status: c.last_status ? status(c.last_status) : null,
unread: c.unread
})
export const emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => e
export const featured_tag = (f: Entity.FeaturedTag): MegalodonEntity.FeaturedTag => f
export const field = (f: Entity.Field): MegalodonEntity.Field => f
export const filter = (f: Entity.Filter): MegalodonEntity.Filter => f
export const history = (h: Entity.History): MegalodonEntity.History => h
export const identity_proof = (i: Entity.IdentityProof): MegalodonEntity.IdentityProof => i
export const instance = (i: Entity.Instance): MegalodonEntity.Instance => i
export const list = (l: Entity.List): MegalodonEntity.List => l
export const marker = (m: Entity.Marker): MegalodonEntity.Marker => {
return {
notifications: {
last_read_id: m.notifications.last_read_id,
version: m.notifications.version,
updated_at: m.notifications.updated_at,
unread_count: m.notifications.pleroma.unread_count
}
}
}
export const mention = (m: Entity.Mention): MegalodonEntity.Mention => m
export const notification = (n: Entity.Notification): MegalodonEntity.Notification => {
if (n.status && n.emoji) {
return {
id: n.id,
account: n.account,
created_at: n.created_at,
status: status(n.status),
emoji: n.emoji,
type: decodeNotificationType(n.type)
}
} else if (n.status) {
return {
id: n.id,
account: n.account,
created_at: n.created_at,
status: status(n.status),
type: decodeNotificationType(n.type)
}
} else {
return {
id: n.id,
account: n.account,
created_at: n.created_at,
type: decodeNotificationType(n.type)
}
}
}
export const poll = (p: Entity.Poll): MegalodonEntity.Poll => p
export const pollOption = (p: Entity.PollOption): MegalodonEntity.PollOption => p
export const preferences = (p: Entity.Preferences): MegalodonEntity.Preferences => p
export const push_subscription = (p: Entity.PushSubscription): MegalodonEntity.PushSubscription => p
export const reaction = (r: Entity.Reaction): MegalodonEntity.Reaction => r
export const relationship = (r: Entity.Relationship): MegalodonEntity.Relationship => ({
id: r.id,
following: r.following,
followed_by: r.followed_by,
blocking: r.blocking,
blocked_by: r.blocked_by,
muting: r.muting,
muting_notifications: r.muting_notifications,
requested: r.requested,
domain_blocking: r.domain_blocking,
showing_reblogs: r.showing_reblogs,
endorsed: r.endorsed,
notifying: r.subscribing
})
export const report = (r: Entity.Report): MegalodonEntity.Report => r
export const results = (r: Entity.Results): MegalodonEntity.Results => ({
accounts: r.accounts.map(a => account(a)),
statuses: r.statuses.map(s => status(s)),
hashtags: r.hashtags.map(h => tag(h))
})
export const scheduled_status = (s: Entity.ScheduledStatus): MegalodonEntity.ScheduledStatus => ({
id: s.id,
scheduled_at: s.scheduled_at,
params: s.params,
media_attachments: s.media_attachments.map(m => attachment(m))
})
export const source = (s: Entity.Source): MegalodonEntity.Source => s
export const stats = (s: Entity.Stats): MegalodonEntity.Stats => s
export const status = (s: Entity.Status): MegalodonEntity.Status => ({
id: s.id,
uri: s.uri,
url: s.url,
account: account(s.account),
in_reply_to_id: s.in_reply_to_id,
in_reply_to_account_id: s.in_reply_to_account_id,
reblog: s.reblog ? status(s.reblog) : null,
content: s.content,
plain_content: s.pleroma.content?.['text/plain'] ? s.pleroma.content['text/plain'] : null,
created_at: s.created_at,
emojis: s.emojis.map(e => emoji(e)),
replies_count: s.replies_count,
reblogs_count: s.reblogs_count,
favourites_count: s.favourites_count,
reblogged: s.reblogged,
favourited: s.favourited,
muted: s.muted,
sensitive: s.sensitive,
spoiler_text: s.spoiler_text,
visibility: s.visibility,
media_attachments: s.media_attachments.map(m => attachment(m)),
mentions: s.mentions.map(m => mention(m)),
tags: s.tags.map(t => tag(t)),
card: s.card ? card(s.card) : null,
poll: s.poll ? poll(s.poll) : null,
application: s.application ? application(s.application) : null,
language: s.language,
pinned: s.pinned,
emoji_reactions: s.pleroma.emoji_reactions ? s.pleroma.emoji_reactions.map(r => reaction(r)) : [],
bookmarked: s.bookmarked ? s.bookmarked : false,
quote: null
})
export const status_params = (s: Entity.StatusParams): MegalodonEntity.StatusParams => s
export const tag = (t: Entity.Tag): MegalodonEntity.Tag => t
export const token = (t: Entity.Token): MegalodonEntity.Token => t
export const urls = (u: Entity.URLs): MegalodonEntity.URLs => u
}
/**
* Interface
*/
export interface Interface {
get<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
put<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
putForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
patch<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
patchForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
post<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
postForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
del<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
cancel(): void
socket(path: string, stream: string, params?: string): WebSocket
}
/**
* Mastodon API client.
*
* Using axios for request, you will handle promises.
*/
export class Client implements Interface {
static DEFAULT_SCOPE = DEFAULT_SCOPE
static DEFAULT_URL = 'https://pleroma.io'
static NO_REDIRECT = NO_REDIRECT
private accessToken: string | null
private baseUrl: string
private userAgent: string
private abortController: AbortController
private proxyConfig: ProxyConfig | false = false
/**
* @param baseUrl hostname or base URL
* @param accessToken access token from OAuth2 authorization
* @param userAgent UserAgent is specified in header on request.
* @param proxyConfig Proxy setting, or set false if don't use proxy.
*/
constructor(
baseUrl: string,
accessToken: string | null = null,
userAgent: string = DEFAULT_UA,
proxyConfig: ProxyConfig | false = false
) {
this.accessToken = accessToken
this.baseUrl = baseUrl
this.userAgent = userAgent
this.proxyConfig = proxyConfig
this.abortController = new AbortController()
axios.defaults.signal = this.abortController.signal
}
/**
* GET request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Query parameters
* @param headers Request header object
*/
public async get<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
params: params,
headers: headers
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.get<T>(this.baseUrl + path, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PUT request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async put<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.put<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PUT request to mastodon REST API for multipart.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async putForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.putForm<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PATCH request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async patch<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.patch<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* PATCH request to mastodon REST API for multipart.
* @param path relative path from baseUrl
* @param params Form data. If you want to post file, please use FormData()
* @param headers Request header object
*/
public async patchForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.patchForm<T>(this.baseUrl + path, params, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* POST request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data
* @param headers Request header object
*/
public async post<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios.post<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* POST request to mastodon REST API for multipart.
* @param path relative path from baseUrl
* @param params Form data
* @param headers Request header object
*/
public async postForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios.postForm<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* DELETE request to mastodon REST API.
* @param path relative path from baseUrl
* @param params Form data
* @param headers Request header object
*/
public async del<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
let options: AxiosRequestConfig = {
data: params,
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
if (this.accessToken) {
options = objectAssignDeep({}, options, {
headers: {
Authorization: `Bearer ${this.accessToken}`
}
})
}
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
}
return axios
.delete(this.baseUrl + path, options)
.catch((err: Error) => {
if (axios.isCancel(err)) {
throw new RequestCanceledError(err.message)
} else {
throw err
}
})
.then((resp: AxiosResponse) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
}
/**
* Cancel all requests in this instance.
* @returns void
*/
public cancel(): void {
return this.abortController.abort()
}
/**
* Get connection and receive websocket connection for Pleroma API.
*
* @param path relative path from baseUrl: normally it is `/streaming`.
* @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
* @returns WebSocket, which inherits from EventEmitter
*/
public socket(path: string, stream: string, params?: string): WebSocket {
if (!this.accessToken) {
throw new Error('accessToken is required')
}
const url = this.baseUrl + path
const streaming = new WebSocket(url, stream, params, this.accessToken, this.userAgent, this.proxyConfig)
process.nextTick(() => {
streaming.start()
})
return streaming
}
}
}
export default PleromaAPI

27
megalodon/src/pleroma/entities/account.ts
View file

@ -1,27 +0,0 @@
/// <reference path="emoji.ts" />
/// <reference path="source.ts" />
/// <reference path="field.ts" />
namespace PleromaEntity {
export type Account = {
id: string
username: string
acct: string
display_name: string
locked: boolean
created_at: string
followers_count: number
following_count: number
statuses_count: number
note: string
url: string
avatar: string
avatar_static: string
header: string
header_static: string
emojis: Array<Emoji>
moved: Account | null
fields: Array<Field>
bot: boolean | null
source?: Source
}
}

8
megalodon/src/pleroma/entities/activity.ts
View file

@ -1,8 +0,0 @@
namespace PleromaEntity {
export type Activity = {
week: string
statuses: string
logins: string
registrations: string
}
}

34
megalodon/src/pleroma/entities/announcement.ts
View file

@ -1,34 +0,0 @@
/// <reference path="tag.ts" />
/// <reference path="emoji.ts" />
/// <reference path="reaction.ts" />
namespace PleromaEntity {
export type Announcement = {
id: string
content: string
starts_at: string | null
ends_at: string | null
published: boolean
all_day: boolean
published_at: string
updated_at: string
read?: boolean
mentions: Array<AnnouncementAccount>
statuses: Array<AnnouncementStatus>
tags: Array<Tag>
emojis: Array<Emoji>
reactions: Array<Reaction>
}
export type AnnouncementAccount = {
id: string
username: string
url: string
acct: string
}
export type AnnouncementStatus = {
id: string
url: string
}
}

7
megalodon/src/pleroma/entities/application.ts
View file

@ -1,7 +0,0 @@
namespace PleromaEntity {
export type Application = {
name: string
website?: string | null
vapid_key?: string | null
}
}

14
megalodon/src/pleroma/entities/async_attachment.ts
View file

@ -1,14 +0,0 @@
/// <reference path="attachment.ts" />
namespace PleromaEntity {
export type AsyncAttachment = {
id: string
type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio'
url: string | null
remote_url: string | null
preview_url: string
text_url: string | null
meta: Meta | null
description: string | null
blurhash: string | null
}
}

49
megalodon/src/pleroma/entities/attachment.ts
View file

@ -1,49 +0,0 @@
namespace PleromaEntity {
export type Sub = {
// For Image, Gifv, and Video
width?: number
height?: number
size?: string
aspect?: number
// For Gifv and Video
frame_rate?: string
// For Audio, Gifv, and Video
duration?: number
bitrate?: number
}
export type Focus = {
x: number
y: number
}
export type Meta = {
original?: Sub
small?: Sub
focus?: Focus
length?: string
duration?: number
fps?: number
size?: string
width?: number
height?: number
aspect?: number
audio_encode?: string
audio_bitrate?: string
audio_channel?: string
}
export type Attachment = {
id: string
type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio'
url: string
remote_url: string | null
preview_url: string | null
text_url: string | null
meta: Meta | null
description: string | null
blurhash: string | null
}
}

17
megalodon/src/pleroma/entities/card.ts
View file

@ -1,17 +0,0 @@
namespace PleromaEntity {
export type Card = {
url: string
title: string
description: string
type: 'link' | 'photo' | 'video' | 'rich'
image?: string
author_name?: string
author_url?: string
provider_name?: string
provider_url?: string
html?: string
width?: number
height?: number
pleroma?: Object
}
}

8
megalodon/src/pleroma/entities/context.ts
View file

@ -1,8 +0,0 @@
/// <reference path="status.ts" />
namespace PleromaEntity {
export type Context = {
ancestors: Array<Status>
descendants: Array<Status>
}
}

11
megalodon/src/pleroma/entities/conversation.ts
View file

@ -1,11 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="status.ts" />
namespace PleromaEntity {
export type Conversation = {
id: string
accounts: Array<Account>
last_status: Status | null
unread: boolean
}
}

9
megalodon/src/pleroma/entities/emoji.ts
View file

@ -1,9 +0,0 @@
namespace PleromaEntity {
export type Emoji = {
shortcode: string
static_url: string
url: string
visible_in_picker: boolean
category: string
}
}

8
megalodon/src/pleroma/entities/featured_tag.ts
View file

@ -1,8 +0,0 @@
namespace PleromaEntity {
export type FeaturedTag = {
id: string
name: string
statuses_count: number
last_status_at: string
}
}

7
megalodon/src/pleroma/entities/field.ts
View file

@ -1,7 +0,0 @@
namespace PleromaEntity {
export type Field = {
name: string
value: string
verified_at: string | null
}
}

12
megalodon/src/pleroma/entities/filter.ts
View file

@ -1,12 +0,0 @@
namespace PleromaEntity {
export type Filter = {
id: string
phrase: string
context: Array<FilterContext>
expires_at: string | null
irreversible: boolean
whole_word: boolean
}
export type FilterContext = string
}

7
megalodon/src/pleroma/entities/history.ts
View file

@ -1,7 +0,0 @@
namespace PleromaEntity {
export type History = {
day: string
uses: number
accounts: number
}
}

9
megalodon/src/pleroma/entities/identity_proof.ts
View file

@ -1,9 +0,0 @@
namespace PleromaEntity {
export type IdentityProof = {
provider: string
provider_username: string
updated_at: string
proof_url: string
profile_url: string
}
}

41
megalodon/src/pleroma/entities/instance.ts
View file

@ -1,41 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="urls.ts" />
/// <reference path="stats.ts" />
namespace PleromaEntity {
export type Instance = {
uri: string
title: string
description: string
email: string
version: string
thumbnail: string | null
urls: URLs
stats: Stats
languages: Array<string>
contact_account: Account | null
max_toot_chars?: number
registrations?: boolean
configuration?: {
statuses: {
max_characters: number
max_media_attachments: number
characters_reserved_per_url: number
}
media_attachments: {
supported_mime_types: Array<string>
image_size_limit: number
image_matrix_limit: number
video_size_limit: number
video_frame_limit: number
video_matrix_limit: number
}
polls: {
max_options: number
max_characters_per_option: number
min_expiration: number
max_expiration: number
}
}
}
}

6
megalodon/src/pleroma/entities/list.ts
View file

@ -1,6 +0,0 @@
namespace PleromaEntity {
export type List = {
id: string
title: string
}
}

12
megalodon/src/pleroma/entities/marker.ts
View file

@ -1,12 +0,0 @@
namespace PleromaEntity {
export type Marker = {
notifications: {
last_read_id: string
version: number
updated_at: string
pleroma: {
unread_count: number
}
}
}
}

8
megalodon/src/pleroma/entities/mention.ts
View file

@ -1,8 +0,0 @@
namespace PleromaEntity {
export type Mention = {
id: string
username: string
url: string
acct: string
}
}

15
megalodon/src/pleroma/entities/notification.ts
View file

@ -1,15 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="status.ts" />
namespace PleromaEntity {
export type Notification = {
account: Account
created_at: string
id: string
status?: Status
emoji?: string
type: NotificationType
}
export type NotificationType = string
}

13
megalodon/src/pleroma/entities/poll.ts
View file

@ -1,13 +0,0 @@
/// <reference path="poll_option.ts" />
namespace PleromaEntity {
export type Poll = {
id: string
expires_at: string | null
expired: boolean
multiple: boolean
votes_count: number
options: Array<PollOption>
voted: boolean
}
}

6
megalodon/src/pleroma/entities/poll_option.ts
View file

@ -1,6 +0,0 @@
namespace PleromaEntity {
export type PollOption = {
title: string
votes_count: number | null
}
}

9
megalodon/src/pleroma/entities/preferences.ts
View file

@ -1,9 +0,0 @@
namespace PleromaEntity {
export type Preferences = {
'posting:default:visibility': 'public' | 'unlisted' | 'private' | 'direct'
'posting:default:sensitive': boolean
'posting:default:language': string | null
'reading:expand:media': 'default' | 'show_all' | 'hide_all'
'reading:expand:spoilers': boolean
}
}

16
megalodon/src/pleroma/entities/push_subscription.ts
View file

@ -1,16 +0,0 @@
namespace PleromaEntity {
export type Alerts = {
follow: boolean
favourite: boolean
mention: boolean
reblog: boolean
poll: boolean
}
export type PushSubscription = {
id: string
endpoint: string
server_key: string
alerts: Alerts
}
}

10
megalodon/src/pleroma/entities/reaction.ts
View file

@ -1,10 +0,0 @@
/// <reference path="./account.ts" />
namespace PleromaEntity {
export type Reaction = {
count: number
me: boolean
name: string
accounts?: Array<Account>
}
}

16
megalodon/src/pleroma/entities/relationship.ts
View file

@ -1,16 +0,0 @@
namespace PleromaEntity {
export type Relationship = {
id: string
following: boolean
followed_by: boolean
blocking: boolean
blocked_by: boolean
muting: boolean
muting_notifications: boolean
requested: boolean
domain_blocking: boolean
showing_reblogs: boolean
endorsed: boolean
subscribing: boolean
}
}

9
megalodon/src/pleroma/entities/report.ts
View file

@ -1,9 +0,0 @@
namespace PleromaEntity {
export type Report = {
id: string
action_taken: string
comment: string
account_id: string
status_ids: Array<string>
}
}

11
megalodon/src/pleroma/entities/results.ts
View file

@ -1,11 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="status.ts" />
/// <reference path="tag.ts" />
namespace PleromaEntity {
export type Results = {
accounts: Array<Account>
statuses: Array<Status>
hashtags: Array<Tag>
}
}

10
megalodon/src/pleroma/entities/scheduled_status.ts
View file

@ -1,10 +0,0 @@
/// <reference path="attachment.ts" />
/// <reference path="status_params.ts" />
namespace PleromaEntity {
export type ScheduledStatus = {
id: string
scheduled_at: string
params: StatusParams
media_attachments: Array<Attachment>
}
}

10
megalodon/src/pleroma/entities/source.ts
View file

@ -1,10 +0,0 @@
/// <reference path="field.ts" />
namespace PleromaEntity {
export type Source = {
privacy: string | null
sensitive: boolean | null
language: string | null
note: string
fields: Array<Field>
}
}

7
megalodon/src/pleroma/entities/stats.ts
View file

@ -1,7 +0,0 @@
namespace PleromaEntity {
export type Stats = {
user_count: number
status_count: number
domain_count: number
}
}

60
megalodon/src/pleroma/entities/status.ts
View file

@ -1,60 +0,0 @@
/// <reference path="account.ts" />
/// <reference path="application.ts" />
/// <reference path="mention.ts" />
/// <reference path="tag.ts" />
/// <reference path="attachment.ts" />
/// <reference path="emoji.ts" />
/// <reference path="card.ts" />
/// <reference path="poll.ts" />
/// <reference path="reaction.ts" />
namespace PleromaEntity {
export type Status = {
id: string
uri: string
url: string
account: Account
in_reply_to_id: string | null
in_reply_to_account_id: string | null
reblog: Status | null
content: string
created_at: string
emojis: Emoji[]
replies_count: number
reblogs_count: number
favourites_count: number
reblogged: boolean | null
favourited: boolean | null
muted: boolean | null
sensitive: boolean
spoiler_text: string
visibility: 'public' | 'unlisted' | 'private' | 'direct'
media_attachments: Array<Attachment>
mentions: Array<Mention>
tags: Array<Tag>
card: Card | null
poll: Poll | null
application: Application | null
language: string | null
pinned: boolean | null
bookmarked?: boolean
// Reblogged status contains only local parameter.
pleroma: {
content?: {
'text/plain': string
}
spoiler_text?: {
'text/plain': string
}
conversation_id?: number
direct_conversation_id?: number | null
emoji_reactions?: Array<Reaction>
expires_at?: string
in_reply_to_account_acct?: string
local: boolean
parent_visible?: boolean
pinned_at?: string
thread_muted?: boolean
}
}
}

12
megalodon/src/pleroma/entities/status_params.ts
View file

@ -1,12 +0,0 @@
namespace PleromaEntity {
export type StatusParams = {
text: string
in_reply_to_id: string | null
media_ids: Array<string> | null
sensitive: boolean | null
spoiler_text: string | null
visibility: 'public' | 'unlisted' | 'private' | 'direct'
scheduled_at: string | null
application_id: string
}
}

10
megalodon/src/pleroma/entities/tag.ts
View file

@ -1,10 +0,0 @@
/// <reference path="history.ts" />
namespace PleromaEntity {
export type Tag = {
name: string
url: string
history: Array<History> | null
following?: boolean
}
}

8
megalodon/src/pleroma/entities/token.ts
View file

@ -1,8 +0,0 @@
namespace PleromaEntity {
export type Token = {
access_token: string
token_type: string
scope: string
created_at: number
}
}

5
megalodon/src/pleroma/entities/urls.ts
View file

@ -1,5 +0,0 @@
namespace PleromaEntity {
export type URLs = {
streaming_api: string
}
}

38
megalodon/src/pleroma/entity.ts
View file

@ -1,38 +0,0 @@
/// <reference path="./entities/account.ts" />
/// <reference path="./entities/activity.ts" />
/// <reference path="./entities/announcement.ts" />
/// <reference path="./entities/application.ts" />
/// <reference path="./entities/async_attachment.ts" />
/// <reference path="./entities/attachment.ts" />
/// <reference path="./entities/card.ts" />
/// <reference path="./entities/context.ts" />
/// <reference path="./entities/conversation.ts" />
/// <reference path="./entities/emoji.ts" />
/// <reference path="./entities/featured_tag.ts" />
/// <reference path="./entities/field.ts" />
/// <reference path="./entities/filter.ts" />
/// <reference path="./entities/history.ts" />>
/// <reference path="./entities/identity_proof.ts" />
/// <reference path="./entities/instance.ts" />
/// <reference path="./entities/list.ts" />
/// <reference path="./entities/marker.ts" />
/// <reference path="./entities/mention.ts" />
/// <reference path="./entities/notification.ts" />
/// <reference path="./entities/poll.ts" />
/// <reference path="./entities/poll_option.ts" />
/// <reference path="./entities/preferences.ts" />
/// <reference path="./entities/push_subscription.ts" />
/// <reference path="./entities/reaction.ts" />
/// <reference path="./entities/relationship.ts" />
/// <reference path="./entities/report.ts" />
/// <reference path="./entities/results.ts" />
/// <reference path="./entities/scheduled_status.ts" />
/// <reference path="./entities/source.ts" />
/// <reference path="./entities/stats.ts" />
/// <reference path="./entities/status.ts" />
/// <reference path="./entities/status_params.ts" />
/// <reference path="./entities/tag.ts" />
/// <reference path="./entities/token.ts" />
/// <reference path="./entities/urls.ts" />
export default PleromaEntity

13
megalodon/src/pleroma/notification.ts
View file

@ -1,13 +0,0 @@
import PleromaEntity from './entity'
namespace PleromaNotificationType {
export const Mention: PleromaEntity.NotificationType = 'mention'
export const Reblog: PleromaEntity.NotificationType = 'reblog'
export const Favourite: PleromaEntity.NotificationType = 'favourite'
export const Follow: PleromaEntity.NotificationType = 'follow'
export const Poll: PleromaEntity.NotificationType = 'poll'
export const PleromaEmojiReaction: PleromaEntity.NotificationType = 'pleroma:emoji_reaction'
export const FollowRequest: PleromaEntity.NotificationType = 'follow_request'
}
export default PleromaNotificationType

343
megalodon/src/pleroma/web_socket.ts
View file

@ -1,343 +0,0 @@
import WS from 'ws'
import dayjs, { Dayjs } from 'dayjs'
import { EventEmitter } from 'events'
import proxyAgent, { ProxyConfig } from '../proxy_config'
import { WebSocketInterface } from '../megalodon'
import PleromaAPI from './api_client'
/**
* WebSocket
* Pleroma is not support streaming. It is support websocket instead of streaming.
* So this class connect to Phoenix websocket for Pleroma.
*/
export default class WebSocket extends EventEmitter implements WebSocketInterface {
public url: string
public stream: string
public params: string | null
public parser: Parser
public headers: { [key: string]: string }
public proxyConfig: ProxyConfig | false = false
private _accessToken: string
private _reconnectInterval: number
private _reconnectMaxAttempts: number
private _reconnectCurrentAttempts: number
private _connectionClosed: boolean
private _client: WS | null
private _pongReceivedTimestamp: Dayjs
private _heartbeatInterval: number = 60000
private _pongWaiting: boolean = false
/**
* @param url Full url of websocket: e.g. https://pleroma.io/api/v1/streaming
* @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
* @param accessToken The access token.
* @param userAgent The specified User Agent.
* @param proxyConfig Proxy setting, or set false if don't use proxy.
*/
constructor(
url: string,
stream: string,
params: string | undefined,
accessToken: string,
userAgent: string,
proxyConfig: ProxyConfig | false = false
) {
super()
this.url = url
this.stream = stream
if (params === undefined) {
this.params = null
} else {
this.params = params
}
this.parser = new Parser()
this.headers = {
'User-Agent': userAgent
}
this.proxyConfig = proxyConfig
this._accessToken = accessToken
this._reconnectInterval = 10000
this._reconnectMaxAttempts = Infinity
this._reconnectCurrentAttempts = 0
this._connectionClosed = false
this._client = null
this._pongReceivedTimestamp = dayjs()
}
/**
* Start websocket connection.
*/
public start() {
this._connectionClosed = false
this._resetRetryParams()
this._startWebSocketConnection()
}
/**
* Reset connection and start new websocket connection.
*/
private _startWebSocketConnection() {
this._resetConnection()
this._setupParser()
this._client = this._connect(this.url, this.stream, this.params, this._accessToken, this.headers, this.proxyConfig)
this._bindSocket(this._client)
}
/**
* Stop current connection.
*/
public stop() {
this._connectionClosed = true
this._resetConnection()
this._resetRetryParams()
}
/**
* Clean up current connection, and listeners.
*/
private _resetConnection() {
if (this._client) {
this._client.close(1000)
this._client.removeAllListeners()
this._client = null
}
if (this.parser) {
this.parser.removeAllListeners()
}
}
/**
* Resets the parameters used in reconnect.
*/
private _resetRetryParams() {
this._reconnectCurrentAttempts = 0
}
/**
* Reconnects to the same endpoint.
*/
private _reconnect() {
setTimeout(() => {
// Skip reconnect when client is connecting.
// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L365
if (this._client && this._client.readyState === WS.CONNECTING) {
return
}
if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) {
this._reconnectCurrentAttempts++
this._clearBinding()
if (this._client) {
// In reconnect, we want to close the connection immediately,
// because recoonect is necessary when some problems occur.
this._client.terminate()
}
// Call connect methods
console.log('Reconnecting')
this._client = this._connect(this.url, this.stream, this.params, this._accessToken, this.headers, this.proxyConfig)
this._bindSocket(this._client)
}
}, this._reconnectInterval)
}
/**
* @param url Base url of streaming endpoint.
* @param stream The specified stream name.
* @param accessToken Access token.
* @param headers The specified headers.
* @param proxyConfig Proxy setting, or set false if don't use proxy.
* @return A WebSocket instance.
*/
private _connect(
url: string,
stream: string,
params: string | null,
accessToken: string,
headers: { [key: string]: string },
proxyConfig: ProxyConfig | false
): WS {
const parameter: Array<string> = [`stream=${stream}`]
if (params) {
parameter.push(params)
}
if (accessToken !== null) {
parameter.push(`access_token=${accessToken}`)
}
const requestURL: string = `${url}/?${parameter.join('&')}`
let options: WS.ClientOptions = {
headers: headers
}
if (proxyConfig) {
options = Object.assign(options, {
agent: proxyAgent(proxyConfig)
})
}
const cli: WS = new WS(requestURL, options)
return cli
}
/**
* Clear binding event for web socket client.
*/
private _clearBinding() {
if (this._client) {
this._client.removeAllListeners('close')
this._client.removeAllListeners('pong')
this._client.removeAllListeners('open')
this._client.removeAllListeners('message')
this._client.removeAllListeners('error')
}
}
/**
* Bind event for web socket client.
* @param client A WebSocket instance.
*/
private _bindSocket(client: WS) {
client.on('close', (code: number, _reason: Buffer) => {
// Refer the code: https://tools.ietf.org/html/rfc6455#section-7.4
if (code === 1000) {
this.emit('close', {})
} else {
console.log(`Closed connection with ${code}`)
// If already called close method, it does not retry.
if (!this._connectionClosed) {
this._reconnect()
}
}
})
client.on('pong', () => {
this._pongWaiting = false
this.emit('pong', {})
this._pongReceivedTimestamp = dayjs()
// It is required to anonymous function since get this scope in checkAlive.
setTimeout(() => this._checkAlive(this._pongReceivedTimestamp), this._heartbeatInterval)
})
client.on('open', () => {
this.emit('connect', {})
// Call first ping event.
setTimeout(() => {
client.ping('')
}, 10000)
})
client.on('message', (data: WS.Data, isBinary: boolean) => {
this.parser.parse(data, isBinary)
})
client.on('error', (err: Error) => {
this.emit('error', err)
})
}
/**
* Set up parser when receive message.
*/
private _setupParser() {
this.parser.on('update', (status: PleromaAPI.Entity.Status) => {
this.emit('update', PleromaAPI.Converter.status(status))
})
this.parser.on('notification', (notification: PleromaAPI.Entity.Notification) => {
this.emit('notification', PleromaAPI.Converter.notification(notification))
})
this.parser.on('delete', (id: string) => {
this.emit('delete', id)
})
this.parser.on('conversation', (conversation: PleromaAPI.Entity.Conversation) => {
this.emit('conversation', PleromaAPI.Converter.conversation(conversation))
})
this.parser.on('status_update', (status: PleromaAPI.Entity.Status) => {
this.emit('status_update', PleromaAPI.Converter.status(status))
})
this.parser.on('error', (err: Error) => {
this.emit('parser-error', err)
})
this.parser.on('heartbeat', _ => {
this.emit('heartbeat', 'heartbeat')
})
}
/**
* Call ping and wait to pong.
*/
private _checkAlive(timestamp: Dayjs) {
const now: Dayjs = dayjs()
// Block multiple calling, if multiple pong event occur.
// It the duration is less than interval, through ping.
if (now.diff(timestamp) > this._heartbeatInterval - 1000 && !this._connectionClosed) {
// Skip ping when client is connecting.
// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L289
if (this._client && this._client.readyState !== WS.CONNECTING) {
this._pongWaiting = true
this._client.ping('')
setTimeout(() => {
if (this._pongWaiting) {
this._pongWaiting = false
this._reconnect()
}
}, 10000)
}
}
}
}
/**
* Parser
* This class provides parser for websocket message.
*/
export class Parser extends EventEmitter {
/**
* @param message Message body of websocket.
*/
public parse(data: WS.Data, isBinary: boolean) {
const message = isBinary ? data : data.toString()
if (typeof message !== 'string') {
this.emit('heartbeat', {})
return
}
if (message === '') {
this.emit('heartbeat', {})
return
}
let event = ''
let payload = ''
let mes = {}
try {
const obj = JSON.parse(message)
event = obj.event
payload = obj.payload
mes = JSON.parse(payload)
} catch (err) {
// delete event does not have json object
if (event !== 'delete') {
this.emit('error', new Error(`Error parsing websocket reply: ${message}, error message: ${err}`))
return
}
}
switch (event) {
case 'update':
this.emit('update', mes as PleromaAPI.Entity.Status)
break
case 'notification':
this.emit('notification', mes as PleromaAPI.Entity.Notification)
break
case 'conversation':
this.emit('conversation', mes as PleromaAPI.Entity.Conversation)
break
case 'delete':
this.emit('delete', payload)
break
case 'status.update':
this.emit('status_update', mes as PleromaAPI.Entity.Status)
break
default:
this.emit('error', new Error(`Unknown event has received: ${message}`))
}
}
}

38
megalodon/test/integration/cancel.spec.ts
View file

@ -1,38 +0,0 @@
import MastodonAPI from '@/mastodon/api_client'
import { Worker } from 'jest-worker'
jest.mock('axios', () => {
const mockAxios = jest.requireActual('axios')
mockAxios.get = (_path: string) => {
return new Promise(resolve => {
setTimeout(() => {
console.log('hoge')
resolve({
data: 'hoge',
status: 200,
statusText: '200OK',
headers: [],
config: {}
})
}, 5000)
})
}
return mockAxios
})
const worker = async (client: MastodonAPI.Client) => {
const w: any = new Worker(require.resolve('./cancelWorker.ts'))
await w.cancel(client)
}
// Could not use jest-worker under typescript.
// I'm waiting for resolve this issue.
// https://github.com/facebook/jest/issues/8872
describe.skip('cancel', () => {
const client = new MastodonAPI.Client('testToken', 'https://pleroma.io/api/v1')
it('should be raised', async () => {
const getPromise = client.get<{}>('/timelines/home')
worker(client)
await expect(getPromise).rejects.toThrow()
})
})

5
megalodon/test/integration/cancelWorker.ts
View file

@ -1,5 +0,0 @@
import MastodonAPI from '@/mastodon/api_client'
export function cancel(client: MastodonAPI.Client) {
return client.cancel()
}

182
megalodon/test/integration/mastodon.spec.ts
View file

@ -1,182 +0,0 @@
import MastodonEntity from '@/mastodon/entity'
import MastodonNotificationType from '@/mastodon/notification'
import Mastodon from '@/mastodon'
import MegalodonNotificationType from '@/notification'
import axios, { AxiosResponse } from 'axios'
jest.mock('axios')
const account: MastodonEntity.Account = {
id: '1',
username: 'h3poteto',
acct: 'h3poteto@pleroma.io',
display_name: 'h3poteto',
locked: false,
created_at: '2019-03-26T21:30:32',
followers_count: 10,
following_count: 10,
statuses_count: 100,
note: 'engineer',
url: 'https://pleroma.io',
avatar: '',
avatar_static: '',
header: '',
header_static: '',
emojis: [],
moved: null,
fields: [],
bot: false
}
const status: MastodonEntity.Status = {
id: '1',
uri: 'http://example.com',
url: 'http://example.com',
account: account,
in_reply_to_id: null,
in_reply_to_account_id: null,
reblog: null,
content: 'hoge',
created_at: '2019-03-26T21:40:32',
emojis: [],
replies_count: 0,
reblogs_count: 0,
favourites_count: 0,
reblogged: null,
favourited: null,
muted: null,
sensitive: false,
spoiler_text: '',
visibility: 'public',
media_attachments: [],
mentions: [],
tags: [],
card: null,
poll: null,
application: {
name: 'Web'
} as MastodonEntity.Application,
language: null,
pinned: null,
bookmarked: false
}
const follow: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '1',
type: MastodonNotificationType.Follow
}
const favourite: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '2',
status: status,
type: MastodonNotificationType.Favourite
}
const mention: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '3',
status: status,
type: MastodonNotificationType.Mention
}
const reblog: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '4',
status: status,
type: MastodonNotificationType.Reblog
}
const poll: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '5',
type: MastodonNotificationType.Poll
}
const followRequest: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '6',
type: MastodonNotificationType.FollowRequest
}
const toot: MastodonEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '7',
status: status,
type: MastodonNotificationType.Status
}
;(axios.CancelToken.source as any).mockImplementation(() => {
return {
token: {
throwIfRequested: () => {},
promise: {
then: () => {},
catch: () => {}
}
}
}
})
describe('getNotifications', () => {
const client = new Mastodon('http://localhost', 'sample token')
const cases: Array<{ event: MastodonEntity.Notification; expected: Entity.NotificationType; title: string }> = [
{
event: follow,
expected: MegalodonNotificationType.Follow,
title: 'follow'
},
{
event: favourite,
expected: MegalodonNotificationType.Favourite,
title: 'favourite'
},
{
event: mention,
expected: MegalodonNotificationType.Mention,
title: 'mention'
},
{
event: reblog,
expected: MegalodonNotificationType.Reblog,
title: 'reblog'
},
{
event: poll,
expected: MegalodonNotificationType.PollExpired,
title: 'poll'
},
{
event: followRequest,
expected: MegalodonNotificationType.FollowRequest,
title: 'followRequest'
},
{
event: toot,
expected: MegalodonNotificationType.Status,
title: 'status'
}
]
cases.forEach(c => {
it(`should be ${c.title} event`, async () => {
const mockResponse: AxiosResponse<Array<MastodonEntity.Notification>> = {
data: [c.event],
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
;(axios.get as any).mockResolvedValue(mockResponse)
const res = await client.getNotifications()
expect(res.data[0].type).toEqual(c.expected)
})
})
})

161
megalodon/test/integration/mastodon/api_client.spec.ts
View file

@ -1,161 +0,0 @@
import MastodonAPI from '@/mastodon/api_client'
import Entity from '@/entity'
import Response from '@/response'
import axios, { AxiosResponse } from 'axios'
jest.mock('axios')
const account: Entity.Account = {
id: '1',
username: 'h3poteto',
acct: 'h3poteto@pleroma.io',
display_name: 'h3poteto',
locked: false,
created_at: '2019-03-26T21:30:32',
followers_count: 10,
following_count: 10,
statuses_count: 100,
note: 'engineer',
url: 'https://pleroma.io',
avatar: '',
avatar_static: '',
header: '',
header_static: '',
emojis: [],
moved: null,
fields: [],
bot: false
}
const status: Entity.Status = {
id: '1',
uri: 'http://example.com',
url: 'http://example.com',
account: account,
in_reply_to_id: null,
in_reply_to_account_id: null,
reblog: null,
content: 'hoge',
plain_content: null,
created_at: '2019-03-26T21:40:32',
emojis: [],
replies_count: 0,
reblogs_count: 0,
favourites_count: 0,
reblogged: null,
favourited: null,
muted: null,
sensitive: false,
spoiler_text: '',
visibility: 'public',
media_attachments: [],
mentions: [],
tags: [],
card: null,
poll: null,
application: {
name: 'Web'
} as Entity.Application,
language: null,
pinned: null,
emoji_reactions: [],
bookmarked: false,
quote: null
}
;(axios.CancelToken.source as any).mockImplementation(() => {
return {
token: {
throwIfRequested: () => {},
promise: {
then: () => {},
catch: () => {}
}
}
}
})
describe('get', () => {
const client = new MastodonAPI.Client('testToken', 'https://pleroma.io/api/v1')
const mockResponse: AxiosResponse<Array<Entity.Status>> = {
data: [status],
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
it('should be responsed', async () => {
;(axios.get as any).mockResolvedValue(mockResponse)
const response: Response<Array<Entity.Status>> = await client.get<Array<Entity.Status>>('/timelines/home')
expect(response.data).toEqual([status])
})
})
describe('put', () => {
const client = new MastodonAPI.Client('testToken', 'https://pleroma.io/api/v1')
const mockResponse: AxiosResponse<Entity.Account> = {
data: account,
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
it('should be responsed', async () => {
;(axios.put as any).mockResolvedValue(mockResponse)
const response: Response<Entity.Account> = await client.put<Entity.Account>('/accounts/update_credentials', {
display_name: 'hoge'
})
expect(response.data).toEqual(account)
})
})
describe('patch', () => {
const client = new MastodonAPI.Client('testToken', 'https://pleroma.io/api/v1')
const mockResponse: AxiosResponse<Entity.Account> = {
data: account,
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
it('should be responsed', async () => {
;(axios.patch as any).mockResolvedValue(mockResponse)
const response: Response<Entity.Account> = await client.patch<Entity.Account>('/accounts/update_credentials', {
display_name: 'hoge'
})
expect(response.data).toEqual(account)
})
})
describe('post', () => {
const client = new MastodonAPI.Client('testToken', 'https://pleroma.io/api/v1')
const mockResponse: AxiosResponse<Entity.Status> = {
data: status,
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
it('should be responsed', async () => {
;(axios.post as any).mockResolvedValue(mockResponse)
const response: Response<Entity.Status> = await client.post<Entity.Status>('/statuses', {
status: 'hoge'
})
expect(response.data).toEqual(status)
})
})
describe('del', () => {
const client = new MastodonAPI.Client('testToken', 'https://pleroma.io/api/v1')
const mockResponse: AxiosResponse<{}> = {
data: {},
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
it('should be responsed', async () => {
;(axios.delete as any).mockResolvedValue(mockResponse)
const response: Response<{}> = await client.del<{}>('/statuses/12asdf34')
expect(response.data).toEqual({})
})
})

187
megalodon/test/integration/pleroma.spec.ts
View file

@ -1,187 +0,0 @@
import PleromaEntity from '@/pleroma/entity'
import Pleroma from '@/pleroma'
import MegalodonNotificationType from '@/notification'
import PleromaNotificationType from '@/pleroma/notification'
import axios, { AxiosResponse } from 'axios'
jest.mock('axios')
const account: PleromaEntity.Account = {
id: '1',
username: 'h3poteto',
acct: 'h3poteto@pleroma.io',
display_name: 'h3poteto',
locked: false,
created_at: '2019-03-26T21:30:32',
followers_count: 10,
following_count: 10,
statuses_count: 100,
note: 'engineer',
url: 'https://pleroma.io',
avatar: '',
avatar_static: '',
header: '',
header_static: '',
emojis: [],
moved: null,
fields: [],
bot: false
}
const status: PleromaEntity.Status = {
id: '1',
uri: 'http://example.com',
url: 'http://example.com',
account: account,
in_reply_to_id: null,
in_reply_to_account_id: null,
reblog: null,
content: 'hoge',
created_at: '2019-03-26T21:40:32',
emojis: [],
replies_count: 0,
reblogs_count: 0,
favourites_count: 0,
reblogged: null,
favourited: null,
muted: null,
sensitive: false,
spoiler_text: '',
visibility: 'public',
media_attachments: [],
mentions: [],
tags: [],
card: null,
poll: null,
application: {
name: 'Web'
} as MastodonEntity.Application,
language: null,
pinned: null,
bookmarked: false,
pleroma: {
local: false
}
}
const follow: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '1',
type: PleromaNotificationType.Follow
}
const favourite: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '2',
type: PleromaNotificationType.Favourite,
status: status
}
const mention: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '3',
type: PleromaNotificationType.Mention,
status: status
}
const reblog: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '4',
type: PleromaNotificationType.Reblog,
status: status
}
const poll: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '5',
type: PleromaNotificationType.Poll,
status: status
}
const emojiReaction: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '6',
type: PleromaNotificationType.PleromaEmojiReaction,
status: status,
emoji: '♥'
}
const followRequest: PleromaEntity.Notification = {
account: account,
created_at: '2021-01-31T23:33:26',
id: '7',
type: PleromaNotificationType.FollowRequest
}
;(axios.CancelToken.source as any).mockImplementation(() => {
return {
token: {
throwIfRequested: () => {},
promise: {
then: () => {},
catch: () => {}
}
}
}
})
describe('getNotifications', () => {
const client = new Pleroma('http://localhost', 'sample token')
const cases: Array<{ event: PleromaEntity.Notification; expected: Entity.NotificationType; title: string }> = [
{
event: follow,
expected: MegalodonNotificationType.Follow,
title: 'follow'
},
{
event: favourite,
expected: MegalodonNotificationType.Favourite,
title: 'favourite'
},
{
event: mention,
expected: MegalodonNotificationType.Mention,
title: 'mention'
},
{
event: reblog,
expected: MegalodonNotificationType.Reblog,
title: 'reblog'
},
{
event: poll,
expected: MegalodonNotificationType.PollExpired,
title: 'poll'
},
{
event: emojiReaction,
expected: MegalodonNotificationType.EmojiReaction,
title: 'emojiReaction'
},
{
event: followRequest,
expected: MegalodonNotificationType.FollowRequest,
title: 'followRequest'
}
]
cases.forEach(c => {
it(`should be ${c.title} event`, async () => {
const mockResponse: AxiosResponse<Array<PleromaEntity.Notification>> = {
data: [c.event],
status: 200,
statusText: '200OK',
headers: {},
config: {}
}
;(axios.get as any).mockResolvedValue(mockResponse)
const res = await client.getNotifications()
expect(res.data[0].type).toEqual(c.expected)
})
})
})

6
megalodon/test/unit/mastodon.spec.ts
View file

@ -1,6 +0,0 @@
describe('test', () => {
it('should be true', () => {
const res = true
expect(res).toEqual(true)
})
})

80
megalodon/test/unit/mastodon/api_client.spec.ts
View file

@ -1,80 +0,0 @@
import MastodonAPI from '@/mastodon/api_client'
import MegalodonEntity from '@/entity'
import MastodonEntity from '@/mastodon/entity'
import MegalodonNotificationType from '@/notification'
import MastodonNotificationType from '@/mastodon/notification'
describe('api_client', () => {
describe('notification', () => {
describe('encode', () => {
it('megalodon notification type should be encoded to mastodon notification type', () => {
const cases: Array<{ src: MegalodonEntity.NotificationType; dist: MastodonEntity.NotificationType }> = [
{
src: MegalodonNotificationType.Follow,
dist: MastodonNotificationType.Follow
},
{
src: MegalodonNotificationType.Favourite,
dist: MastodonNotificationType.Favourite
},
{
src: MegalodonNotificationType.Reblog,
dist: MastodonNotificationType.Reblog
},
{
src: MegalodonNotificationType.Mention,
dist: MastodonNotificationType.Mention
},
{
src: MegalodonNotificationType.PollExpired,
dist: MastodonNotificationType.Poll
},
{
src: MegalodonNotificationType.FollowRequest,
dist: MastodonNotificationType.FollowRequest
},
{
src: MegalodonNotificationType.Status,
dist: MastodonNotificationType.Status
}
]
cases.forEach(c => {
expect(MastodonAPI.Converter.encodeNotificationType(c.src)).toEqual(c.dist)
})
})
})
describe('decode', () => {
it('mastodon notification type should be decoded to megalodon notification type', () => {
const cases: Array<{ src: MastodonEntity.NotificationType; dist: MegalodonEntity.NotificationType }> = [
{
src: MastodonNotificationType.Follow,
dist: MegalodonNotificationType.Follow
},
{
src: MastodonNotificationType.Favourite,
dist: MegalodonNotificationType.Favourite
},
{
src: MastodonNotificationType.Mention,
dist: MegalodonNotificationType.Mention
},
{
src: MastodonNotificationType.Reblog,
dist: MegalodonNotificationType.Reblog
},
{
src: MastodonNotificationType.Poll,
dist: MegalodonNotificationType.PollExpired
},
{
src: MastodonNotificationType.FollowRequest,
dist: MegalodonNotificationType.FollowRequest
}
]
cases.forEach(c => {
expect(MastodonAPI.Converter.decodeNotificationType(c.src)).toEqual(c.dist)
})
})
})
})
})

200
megalodon/test/unit/pleroma/api_client.spec.ts
View file

@ -1,200 +0,0 @@
import PleromaAPI from '@/pleroma/api_client'
import MegalodonEntity from '@/entity'
import PleromaEntity from '@/pleroma/entity'
import MegalodonNotificationType from '@/notification'
import PleromaNotificationType from '@/pleroma/notification'
const account: PleromaEntity.Account = {
id: '1',
username: 'h3poteto',
acct: 'h3poteto@pleroma.io',
display_name: 'h3poteto',
locked: false,
created_at: '2019-03-26T21:30:32',
followers_count: 10,
following_count: 10,
statuses_count: 100,
note: 'engineer',
url: 'https://pleroma.io',
avatar: '',
avatar_static: '',
header: '',
header_static: '',
emojis: [],
moved: null,
fields: [],
bot: false
}
describe('api_client', () => {
describe('notification', () => {
describe('encode', () => {
it('megalodon notification type should be encoded to pleroma notification type', () => {
const cases: Array<{ src: MegalodonEntity.NotificationType; dist: PleromaEntity.NotificationType }> = [
{
src: MegalodonNotificationType.Follow,
dist: PleromaNotificationType.Follow
},
{
src: MegalodonNotificationType.Favourite,
dist: PleromaNotificationType.Favourite
},
{
src: MegalodonNotificationType.Reblog,
dist: PleromaNotificationType.Reblog
},
{
src: MegalodonNotificationType.Mention,
dist: PleromaNotificationType.Mention
},
{
src: MegalodonNotificationType.PollExpired,
dist: PleromaNotificationType.Poll
},
{
src: MegalodonNotificationType.EmojiReaction,
dist: PleromaNotificationType.PleromaEmojiReaction
},
{
src: MegalodonNotificationType.FollowRequest,
dist: PleromaNotificationType.FollowRequest
}
]
cases.forEach(c => {
expect(PleromaAPI.Converter.encodeNotificationType(c.src)).toEqual(c.dist)
})
})
})
describe('decode', () => {
it('pleroma notification type should be decoded to megalodon notification type', () => {
const cases: Array<{ src: PleromaEntity.NotificationType; dist: MegalodonEntity.NotificationType }> = [
{
src: PleromaNotificationType.Follow,
dist: MegalodonNotificationType.Follow
},
{
src: PleromaNotificationType.Favourite,
dist: MegalodonNotificationType.Favourite
},
{
src: PleromaNotificationType.Mention,
dist: MegalodonNotificationType.Mention
},
{
src: PleromaNotificationType.Reblog,
dist: MegalodonNotificationType.Reblog
},
{
src: PleromaNotificationType.Poll,
dist: MegalodonNotificationType.PollExpired
},
{
src: PleromaNotificationType.PleromaEmojiReaction,
dist: MegalodonNotificationType.EmojiReaction
},
{
src: PleromaNotificationType.FollowRequest,
dist: MegalodonNotificationType.FollowRequest
}
]
cases.forEach(c => {
expect(PleromaAPI.Converter.decodeNotificationType(c.src)).toEqual(c.dist)
})
})
})
})
describe('status', () => {
describe('plain content is included', () => {
it('plain content in pleroma entity should be exported in plain_content column', () => {
const plainContent = 'hoge\nfuga\nfuga'
const content = '<p>hoge<br>fuga<br>fuga</p>'
const pleromaStatus: PleromaEntity.Status = {
id: '1',
uri: 'https://pleroma.io/notice/1',
url: 'https://pleroma.io/notice/1',
account: account,
in_reply_to_id: null,
in_reply_to_account_id: null,
reblog: null,
content: content,
created_at: '2019-03-26T21:40:32',
emojis: [],
replies_count: 0,
reblogs_count: 0,
favourites_count: 0,
reblogged: null,
favourited: null,
muted: null,
sensitive: false,
spoiler_text: '',
visibility: 'public',
media_attachments: [],
mentions: [],
tags: [],
card: null,
poll: null,
application: {
name: 'Web'
} as MastodonEntity.Application,
language: null,
pinned: null,
bookmarked: false,
pleroma: {
content: {
'text/plain': plainContent
},
local: false
}
}
const megalodonStatus = PleromaAPI.Converter.status(pleromaStatus)
expect(megalodonStatus.plain_content).toEqual(plainContent)
expect(megalodonStatus.content).toEqual(content)
})
})
describe('plain content is not included', () => {
it('plain_content should be null', () => {
const content = '<p>hoge<br>fuga<br>fuga</p>'
const pleromaStatus: PleromaEntity.Status = {
id: '1',
uri: 'https://pleroma.io/notice/1',
url: 'https://pleroma.io/notice/1',
account: account,
in_reply_to_id: null,
in_reply_to_account_id: null,
reblog: null,
content: content,
created_at: '2019-03-26T21:40:32',
emojis: [],
replies_count: 0,
reblogs_count: 0,
favourites_count: 0,
reblogged: null,
favourited: null,
muted: null,
sensitive: false,
spoiler_text: '',
visibility: 'public',
media_attachments: [],
mentions: [],
tags: [],
card: null,
poll: null,
application: {
name: 'Web'
} as MastodonEntity.Application,
language: null,
pinned: null,
bookmarked: false,
pleroma: {
local: false
}
}
const megalodonStatus = PleromaAPI.Converter.status(pleromaStatus)
expect(megalodonStatus.plain_content).toBeNull()
expect(megalodonStatus.content).toEqual(content)
})
})
})
})

180
megalodon/test/unit/webo_socket.spec.ts
View file

@ -1,180 +0,0 @@
import { Parser } from '@/mastodon/web_socket'
import Entity from '@/entity'
const account: Entity.Account = {
id: '1',
username: 'h3poteto',
acct: 'h3poteto@pleroma.io',
display_name: 'h3poteto',
locked: false,
created_at: '2019-03-26T21:30:32',
followers_count: 10,
following_count: 10,
statuses_count: 100,
note: 'engineer',
url: 'https://pleroma.io',
avatar: '',
avatar_static: '',
header: '',
header_static: '',
emojis: [],
moved: null,
fields: [],
bot: false
}
const status: Entity.Status = {
id: '1',
uri: 'http://example.com',
url: 'http://example.com',
account: account,
in_reply_to_id: null,
in_reply_to_account_id: null,
reblog: null,
content: 'hoge',
plain_content: 'hoge',
created_at: '2019-03-26T21:40:32',
emojis: [],
replies_count: 0,
reblogs_count: 0,
favourites_count: 0,
reblogged: null,
favourited: null,
muted: null,
sensitive: false,
spoiler_text: '',
visibility: 'public',
media_attachments: [],
mentions: [],
tags: [],
card: null,
poll: null,
application: {
name: 'Web'
} as Entity.Application,
language: null,
pinned: null,
emoji_reactions: [],
bookmarked: false,
quote: null
}
const notification: Entity.Notification = {
id: '1',
account: account,
status: status,
type: 'favourite',
created_at: '2019-04-01T17:01:32'
}
const conversation: Entity.Conversation = {
id: '1',
accounts: [account],
last_status: status,
unread: true
}
describe('Parser', () => {
let parser: Parser
beforeEach(() => {
parser = new Parser()
})
describe('parse', () => {
describe('message is heartbeat', () => {
describe('message is an object', () => {
const message = Buffer.alloc(0)
it('should be called', () => {
const spy = jest.fn()
parser.once('heartbeat', spy)
parser.parse(message, true)
expect(spy).toHaveBeenCalledWith({})
})
})
describe('message is empty string', () => {
const message: string = ''
it('should be called', () => {
const spy = jest.fn()
parser.once('heartbeat', spy)
parser.parse(Buffer.from(message), false)
expect(spy).toHaveBeenCalledWith({})
})
})
})
describe('message is not json', () => {
describe('event is delete', () => {
const message = JSON.stringify({
event: 'delete',
payload: '12asdf34'
})
it('should be called', () => {
const spy = jest.fn()
parser.once('delete', spy)
parser.parse(Buffer.from(message), false)
expect(spy).toHaveBeenCalledWith('12asdf34')
})
})
describe('event is not delete', () => {
const message = JSON.stringify({
event: 'event',
payload: '12asdf34'
})
it('should be called', () => {
const error = jest.fn()
const deleted = jest.fn()
parser.once('error', error)
parser.once('delete', deleted)
parser.parse(Buffer.from(message), false)
expect(error).toHaveBeenCalled()
expect(deleted).not.toHaveBeenCalled()
})
})
})
describe('message is json', () => {
describe('event is update', () => {
const message = JSON.stringify({
event: 'update',
payload: JSON.stringify(status)
})
it('should be called', () => {
const spy = jest.fn()
parser.once('update', spy)
parser.parse(Buffer.from(message), false)
expect(spy).toHaveBeenCalledWith(status)
})
})
describe('event is notification', () => {
const message = JSON.stringify({
event: 'notification',
payload: JSON.stringify(notification)
})
it('should be called', () => {
const spy = jest.fn()
parser.once('notification', spy)
parser.parse(Buffer.from(message), false)
expect(spy).toHaveBeenCalledWith(notification)
})
})
describe('event is conversation', () => {
const message = JSON.stringify({
event: 'conversation',
payload: JSON.stringify(conversation)
})
it('should be called', () => {
const spy = jest.fn()
parser.once('conversation', spy)
parser.parse(Buffer.from(message), false)
expect(spy).toHaveBeenCalledWith(conversation)
})
})
})
})
})