From 11f56b7010db721141957785caa5cc8846067f8e Mon Sep 17 00:00:00 2001 From: Xylight Date: Sat, 7 Feb 2026 21:54:19 -0800 Subject: [PATCH] refactor: make piefed adaptor (adapter?) declarative --- src/lib/api/client.svelte.ts | 2 +- src/lib/api/piefed/adapter.ts | 1637 ++++++++++++++------------------ src/lib/api/piefed/rewrite.ts | 81 +- src/lib/api/piefed/schema.d.ts | 4 +- 4 files changed, 770 insertions(+), 954 deletions(-) diff --git a/src/lib/api/client.svelte.ts b/src/lib/api/client.svelte.ts index 85f9eafd..8b797bdd 100644 --- a/src/lib/api/client.svelte.ts +++ b/src/lib/api/client.svelte.ts @@ -84,7 +84,7 @@ export function client({ return new Client(instanceToURL(instanceURL), { fetchFunction: (input, init) => customFetch(func, input, init, jwt), headers: headers, - }) as BaseClient + }) as unknown as BaseClient } // here for parts where i forgor to switch diff --git a/src/lib/api/piefed/adapter.ts b/src/lib/api/piefed/adapter.ts index dfac8e05..f3c0cfa1 100644 --- a/src/lib/api/piefed/adapter.ts +++ b/src/lib/api/piefed/adapter.ts @@ -1,11 +1,6 @@ import createClient from 'openapi-fetch' -import { - BaseClient, - type ClientType, - type NullableFnArg, - type NullableFnReturn, -} from '../base' -import type { SubscribedType } from '../types' +import type { BaseClient, ClientType } from '../base' +import type * as types from '../types' import { fromCreateComment, fromCreatePost, @@ -33,52 +28,119 @@ import { toSortType, toTopicView, } from './rewrite' -import type { paths } from './schema' +import type { components, paths } from './schema' -export class PiefedClient implements BaseClient { - type: ClientType = { name: 'piefed', baseUrl: '/api/alpha' } +type piefed = components['schemas'] - static constants = { password: { minLength: 6, maxLength: 128 } } +type ApiClient = ReturnType> +type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' - #client: ReturnType> +// i think this should be inside baseclient maybe +type MethodName = NonNullable< + { + [K in keyof BaseClient]: BaseClient[K] extends (...args: any[]) => any + ? K + : never + }[keyof BaseClient] +> - constructor( - baseUrl: string, - args: { - fetchFunction: (input: any, init: any) => Promise - headers: any - }, - ) { - this.#client = createClient({ - baseUrl: baseUrl, - // @ts-expect-error i dont feel like fixing this right now - fetch: args.fetchFunction, - headers: args.headers, - }) +type MethodConfig< + K extends MethodName, + P extends keyof paths = keyof paths, + M extends HttpMethod = 'GET', +> = { + method: HttpMethod + path: keyof paths + query?: (params: Parameters[0]) => unknown + body?: (params: Parameters[0]) => unknown + transform: ( + response: SuccessResponse, + params: Parameters[0], + ) => Awaited> +} + +type MethodDef = + | MethodConfig + | ((client: ApiClient, params: any) => Promise) + | 'unsupported' + +type MethodDefinitions = { + [K in MethodName]: MethodDef +} + +type SuccessResponse< + P extends keyof paths, + M extends HttpMethod, +> = paths[P] extends { + [K in M]: { responses: { 200: { content: { 'application/json': infer R } } } } +} + ? R + : paths[P] extends { + [K in M]: { + responses: { 201: { content: { 'application/json': infer R } } } + } + } + ? R + : never + +function assertData(response: { data?: T; error?: unknown }): T { + if (response.error || !response.data) { + throw new Error( + `API error: ${JSON.stringify(response.error ?? 'No data returned')}`, + ) } + return response.data +} - async getSite(): ReturnType { - const response = (await this.#client.GET('/api/alpha/site', {})).data! +const transforms = { + postView: (r: any) => ({ post_view: toPostView(r.post_view) }), - return { - admins: response.admins.map(toPersonView), + commentView: (r: any) => ({ + comment_view: toCommentView(r.comment_view), + recipient_ids: [], + }), + + communityView: (r: any) => ({ + ...r, + community_view: toCommunityView(r.community_view), + }), + + privateMessageView: (r: any) => ({ + ...r, + private_message_view: toPrivateMessageView(r.private_message_view), + }), + + moderators: (r: any) => ({ + moderators: r.moderators.map((i: any) => ({ + community: toCommunity(i.community), + moderator: toPerson(i.moderator), + })), + }), +} + +const methods: MethodDefinitions = { + getSite: { + method: 'GET', + path: '/api/alpha/site', + transform: (r: piefed['GetSiteResponse']) => ({ + admins: r.admins.map(toPersonView), site_view: { counts: { comments: -1, communities: -1, posts: -1, site_id: -1, - users: response.site.user_count ?? -1, + users: r.site.user_count ?? -1, users_active_day: -1, users_active_half_year: -1, users_active_month: -1, users_active_week: -1, }, - local_site: toLocalSite(response.site), - site: response.site, + local_site: toLocalSite(r.site), + site: r.site, }, all_languages: - (response.site.all_languages as { + (r.site.all_languages as { code: string id: number name: string @@ -87,963 +149,740 @@ export class PiefedClient implements BaseClient { custom_emojis: [], discussion_languages: [], taglines: [], - version: response.version, - my_user: response.my_user ? toMyUser(response.my_user) : undefined, - } - } + version: r.version, + my_user: r.my_user ? toMyUser(r.my_user) : undefined, + }), + }, - async createPost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post', { - body: fromCreatePost(params), - }) - ).data! + getSiteMetadata: { + method: 'GET', + path: '/api/alpha/post/site_metadata', + query: (p) => p, + transform: (r) => r, + }, - return { - post_view: toPostView(response.post_view), - } - } - async getPost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/post', { - params: { query: fromGetPost(params) }, - }) - ).data! + getFederatedInstances: { + method: 'GET', + path: '/api/alpha/federated_instances', + transform: (r) => r, + }, - return { - community_view: toCommunityView(response.community_view!), - cross_posts: response.cross_posts!.map(toPostView), - moderators: response.moderators!.map((i) => ({ + blockInstance: { + method: 'POST', + path: '/api/alpha/site/block', + transform: (r) => r, + }, + + createPost: { + method: 'POST', + path: '/api/alpha/post', + body: fromCreatePost, + transform: transforms.postView, + }, + + getPost: { + method: 'GET', + path: '/api/alpha/post', + query: fromGetPost, + transform: (r: piefed['GetPostResponse']) => ({ + community_view: toCommunityView(r.community_view!), + cross_posts: r.cross_posts!.map(toPostView), + moderators: r.moderators!.map((i: any) => ({ community: toCommunity(i.community), moderator: toPerson(i.moderator), })), - post_view: toPostView(response.post_view), - } - } + post_view: toPostView(r.post_view), + }), + }, - async editPost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.PUT('/api/alpha/post', { body: params }) - ).data! + editPost: { + method: 'PUT', + path: '/api/alpha/post', + transform: transforms.postView, + }, - return { - post_view: toPostView(response.post_view), - } - } - async deletePost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post/delete', { body: params }) - ).data! + deletePost: { + method: 'POST', + path: '/api/alpha/post/delete', + transform: transforms.postView, + }, - return { - post_view: toPostView(response.post_view), - } - } + removePost: { + method: 'POST', + path: '/api/alpha/post/remove', + transform: transforms.postView, + }, - async removePost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post/remove', { body: params }) - ).data! + getPosts: { + method: 'GET', + path: '/api/alpha/post/list', + query: fromGetPosts, + transform: (r: piefed['ListPostsResponse'], p) => ({ + ...r, + posts: r.posts.map(toPostView), + next_page: String(Number(p.page_cursor ?? 1) + 1), + }), + }, - return { - post_view: toPostView(response.post_view), - } - } + likePost: { + method: 'POST', + path: '/api/alpha/post/like', + transform: transforms.postView, + }, - async getPosts( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/post/list', { - params: { query: fromGetPosts(params) }, - }) - ).data! + markPostAsRead: { + method: 'POST', + path: '/api/alpha/post/mark_as_read', + transform: () => ({ success: true }), + }, - return { - ...response, - posts: response.posts.map(toPostView), - next_page: (Number(params.page_cursor ?? 1) + 1).toString(), - } - } - async likePost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post/like', { - body: { ...params }, - }) - ).data! + lockPost: { + method: 'POST', + path: '/api/alpha/post/lock', + transform: transforms.postView, + }, - return { - post_view: toPostView(response.post_view), - } - } + featurePost: { + method: 'POST', + path: '/api/alpha/post/feature', + transform: transforms.postView, + }, - async generateTotpSecret(): ReturnType { - throw new Error('unsupported') - } - async listLogins(): ReturnType { - throw new Error('unsupported') - } - async listAllMedia(): ReturnType { - throw new Error('unsupported') - } - async updateTotp(): ReturnType { - throw new Error('unsupported') - } - async getModlog(): ReturnType { - throw new Error('unsupported') - } - async search( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/search', { - params: { - query: fromSearch(params), - }, - }) - ).data! + savePost: { + method: 'PUT', + path: '/api/alpha/post/save', + transform: transforms.postView, + }, - return { - comments: [], - communities: response.communities.map(toCommunityView), - posts: response.posts.map(toPostView), - users: response.users.map(toPersonView), - type_: response.type_, - } - } - async resolveObject( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/resolve_object', { - params: { query: params }, - }) - ).data! - - return { - comment: response.comment ? toCommentView(response.comment) : undefined, - community: response.community - ? toCommunityView(response.community) - : undefined, - post: response.post ? toPostView(response.post) : undefined, - person: response.person ? toPersonView(response.person) : undefined, - } - } - async createCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/community', { body: params }) - ).data! - - return { - ...response, - community_view: toCommunityView(response.community_view), - } - } - async getCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/community', { - params: { - query: params, - }, - }) - ).data! - - return { - ...response, - community_view: toCommunityView(response.community_view), - moderators: response.moderators.map((i) => ({ - community: toCommunity(i.community), - moderator: toPerson(i.moderator), - })), - } - } - async editCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.PUT('/api/alpha/community', { - body: params, - }) - ).data! - - return { - ...response, - community_view: toCommunityView(response.community_view), - } - } - async listCommunities( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/community/list', { - params: { - query: fromListCommunities(params), - }, - }) - ).data! - - return { - communities: response.communities.map(toCommunityView), - } - } - async followCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/community/follow', { body: params }) - ).data! - - return { - ...response, - community_view: toCommunityView(response.community_view), - } - } - async blockCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/community/block', { body: params }) - ).data! - - return { - ...response, - community_view: toCommunityView(response.community_view), - } - } - async deleteCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/community/delete', { body: params }) - ).data! - - return { - ...response, - community_view: toCommunityView(response.community_view), - } - } - async hideCommunity(): ReturnType { - throw new Error('unsupported') - } - async removeCommunity(): ReturnType { - throw new Error('unsupported') - } - async banFromCommunity( - params: Parameters[0], - ): ReturnType { - const response = // piefed has separate methods for ban/unban - ( - params.ban - ? await this.#client.POST('/api/alpha/community/moderate/ban', { - body: { - ...params, - expiredAt: new Date( - params.expires ?? '6767-06-07T00:00:00.000Z', - ).toISOString(), - user_id: params.person_id, - reason: params.reason ?? 'No reason provided.', - }, - }) - : await this.#client.PUT('/api/alpha/community/moderate/unban', { - body: { - community_id: params.community_id, - user_id: params.person_id, - }, - }) - ).data! - - return { - banned: params.ban, - person_view: { - person: toPerson(response.banned_user!), - counts: { comment_count: -1, person_id: -1, post_count: -1 }, - is_admin: false, - }, - } - } - async addModToCommunity( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/community/mod', { body: params }) - ).data! - - return { - moderators: response.moderators.map((i) => ({ - community: toCommunity(i.community), - moderator: toPerson(i.moderator), - })), - } - } - async markPostAsRead( - params: Parameters[0], - ): ReturnType { - await this.#client.POST('/api/alpha/post/mark_as_read', { - body: { ...params }, - }) - - return { - success: true, - } - } - async hidePost(): ReturnType { - throw new Error('unsupported') - } - async lockPost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post/lock', { body: params }) - ).data! - - return { - ...response, - post_view: toPostView(response.post_view), - } - } - async featurePost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post/feature', { body: params }) - ).data! - - return { - ...response, - post_view: toPostView(response.post_view), - } - } - async listPostLikes( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/post/like/list', { - params: { query: params }, - }) - ).data! - - return { - post_likes: response.post_likes!.map((i) => ({ + listPostLikes: { + method: 'GET', + path: '/api/alpha/post/like/list', + query: (p) => p, + transform: (r: piefed['ListPostLikesResponse']) => ({ + post_likes: r.post_likes!.map((i: any) => ({ ...i, creator_banned_from_community: false, creator: toPerson(i.creator), })), - } - } - async savePost( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.PUT('/api/alpha/post/save', { body: params }) - ).data! + }), + }, - return { - post_view: toPostView(response.post_view), - } - } - async createPostReport( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/post/report', { body: params }) - ).data! - - return { + createPostReport: { + method: 'POST', + path: '/api/alpha/post/report', + body: (p) => ({ ...p, report_remote: false }), + transform: (r: piefed['PostReportResponse']) => ({ post_report_view: { - ...response.post_report_view, - community: toCommunity(response.post_report_view.community), - post: toPost(response.post_report_view.post), - creator: toPerson(response.post_report_view.creator), - // TODO figure out if this is a bug or not - resolver: response.post_report_view.resolver - ? toPerson(response.post_report_view.resolver!) + ...r.post_report_view, + community: toCommunity(r.post_report_view.community), + post: toPost(r.post_report_view.post), + creator: toPerson(r.post_report_view.creator), + resolver: (r.post_report_view as any).resolver + ? toPerson((r.post_report_view as any).resolver) : undefined, - post_creator: toPerson(response.post_report_view.post_creator), + post_creator: toPerson(r.post_report_view.post_creator), read: false, hidden: false, creator_banned_from_community: false, unread_comments: -1, }, - } - } - async resolvePostReport(): ReturnType { - throw new Error('unsupported') - } - async listPostReports(): ReturnType { - throw new Error('unsupported') - } - async getSiteMetadata( - params: Parameters[0], - ): ReturnType { - return ( - await this.#client.GET('/api/alpha/post/site_metadata', { - params: { query: params }, - }) - ).data! - } + }), + }, - async createComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/comment', { - body: fromCreateComment(params), - }) - ).data! + voteOnPoll: { + method: 'POST', + path: '/api/alpha/post/poll_vote', + transform: (r: piefed['PollVoteResponse']) => toPostView(r.post_view), + }, - return { - ...response, - comment_view: toCommentView(response.comment_view), + createComment: { + method: 'POST', + path: '/api/alpha/comment', + body: fromCreateComment, + transform: (r: piefed['GetCommentResponse']) => ({ + ...r, + comment_view: toCommentView(r.comment_view), recipient_ids: [], - } - } - async editComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.PUT('/api/alpha/comment', { - body: { ...params, body: params.content }, - }) - ).data! + }), + }, - return { - comment_view: toCommentView(response.comment_view), + editComment: { + method: 'PUT', + path: '/api/alpha/comment', + body: (p) => ({ ...p, body: p.content, distinguished: false }), + transform: (r: piefed['GetCommentResponse']) => ({ + ...r, + comment_view: toCommentView(r.comment_view), recipient_ids: [], - } - } - async deleteComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/comment/delete', { body: params }) - ).data! + }), + }, - return { - comment_view: toCommentView(response.comment_view), + deleteComment: { + method: 'POST', + path: '/api/alpha/comment/delete', + transform: (r: piefed['GetCommentResponse']) => ({ + ...r, + comment_view: toCommentView(r.comment_view), recipient_ids: [], - } - } - async removeComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/comment/remove', { body: params }) - ).data! + }), + }, - return { - comment_view: toCommentView(response.comment_view), + removeComment: { + method: 'POST', + path: '/api/alpha/comment/remove', + transform: (r: piefed['GetCommentResponse']) => ({ + ...r, + comment_view: toCommentView(r.comment_view), recipient_ids: [], - } - } - async markCommentReplyAsRead( - params: Parameters[0], - ): ReturnType { - await this.#client.POST('/api/alpha/comment/mark_as_read', { - body: params, - }) - } - async likeComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/comment/like', { - body: { - ...params, - // TODO add private votes - private: false, - }, - }) - ).data! + }), + }, - return { - comment_view: toCommentView(response.comment_view), - recipient_ids: [], - } - } + markCommentReplyAsRead: { + method: 'POST', + path: '/api/alpha/comment/mark_as_read', + transform: () => undefined, + }, - async listCommentLikes( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/comment/like/list', { - params: { query: params }, - }) - ).data! + likeComment: { + method: 'POST', + path: '/api/alpha/comment/like', + body: (p) => ({ ...p, private: false }), + transform: transforms.commentView, + }, - return { - comment_likes: response.comment_likes!.map((i) => ({ + listCommentLikes: { + method: 'GET', + path: '/api/alpha/comment/like/list', + query: (p) => p, + transform: (r: piefed['ListCommentLikesResponse']) => ({ + comment_likes: r.comment_likes!.map((i: any) => ({ ...i, creator: toPerson(i.creator), })), - } - } - async saveComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.PUT('/api/alpha/comment/save', { body: params }) - ).data! + }), + }, - return { - ...response, - comment_view: toCommentView(response.comment_view), + saveComment: { + method: 'PUT', + path: '/api/alpha/comment/save', + transform: (r: piefed['GetCommentResponse']) => ({ + ...r, + comment_view: toCommentView(r.comment_view), recipient_ids: [], - } - } - async distinguishComment(): ReturnType { - throw new Error('unsupported') - } + }), + }, - async getComments( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/comment/list', { - params: { query: fromGetComments(params) }, - }) - ).data! + getComments: { + method: 'GET', + path: '/api/alpha/comment/list', + query: fromGetComments, + transform: (r: piefed['ListCommentsResponse']) => ({ + comments: r.comments.map(toCommentView), + }), + }, - return { - comments: response.comments.map(toCommentView), - } - } - - async getComment( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/comment', { - params: { query: params }, - }) - ).data! - - return { - ...response, - comment_view: toCommentView(response.comment_view), + getComment: { + method: 'GET', + path: '/api/alpha/comment', + query: (p) => p, + transform: (r: piefed['GetCommentResponse']) => ({ + ...r, + comment_view: toCommentView(r.comment_view), recipient_ids: [], - } - } - async createCommentReport( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/comment/report', { - body: { - ...params, - // TODO add remote reports - report_remote: false, - }, - }) - ).data! + }), + }, - return { - ...response, + // createCommentReport: async (client, params) => { + // const response = assertData( + // await client.POST('/api/alpha/comment/report', { + // body: { + // ...params, + // report_remote: false, + // reason: params.reason ?? '', + // } as any, + // }), + // ) + // return { + // ...response, + // comment_report_view: { + // ...response.comment_report_view, + // comment: toComment(response.comment_report_view.comment), + // community: toCommunity(response.comment_report_view.community), + // comment_creator: toPerson(response.comment_report_view.comment_creator), + // creator: toPerson(response.comment_report_view.creator), + // post: toPost(response.comment_report_view.post), + // resolver: (response.comment_report_view as any).resolver + // ? toPerson((response.comment_report_view as any).resolver) + // : undefined, + // subscribed: response.comment_report_view.subscribed as SubscribedType, + // }, + // } + // }, + + createCommentReport: { + method: 'POST', + path: '/api/alpha/comment/report', + body: (p) => ({ ...p, report_report: false, reason: p.reason ?? '' }), + transform: (r: piefed['GetCommentReportResponse']) => ({ + ...r, comment_report_view: { - ...response.comment_report_view, - comment: toComment(response.comment_report_view.comment), - community: toCommunity(response.comment_report_view.community), - comment_creator: toPerson(response.comment_report_view.comment_creator), - creator: toPerson(response.comment_report_view.creator), - post: toPost(response.comment_report_view.post), - // TODO figure out what's wrong here - resolver: response.comment_report_view.resolver - ? toPerson(response.comment_report_view.resolver) + ...r.comment_report_view, + comment: toComment(r.comment_report_view.comment), + community: toCommunity(r.comment_report_view.community), + comment_creator: toPerson(r.comment_report_view.comment_creator), + creator: toPerson(r.comment_report_view.creator), + post: toPost(r.comment_report_view.post), + resolver: (r.comment_report_view as any).resolver + ? toPerson((r.comment_report_view as any).resolver) : undefined, - subscribed: response.comment_report_view.subscribed as SubscribedType, + subscribed: r.comment_report_view.subscribed as types.SubscribedType, + }, + }), + }, + + createCommunity: { + method: 'POST', + path: '/api/alpha/community', + transform: (r: piefed['CommunityResponse']) => ({ + ...r, + community_view: toCommunityView(r.community_view), + }), + }, + + getCommunity: { + method: 'GET', + path: '/api/alpha/community', + query: (p) => p, + transform: (r: piefed['GetCommunityResponse']) => ({ + ...r, + community_view: toCommunityView(r.community_view), + moderators: r.moderators.map((i: any) => ({ + community: toCommunity(i.community), + moderator: toPerson(i.moderator), + })), + }), + }, + + editCommunity: { + method: 'PUT', + path: '/api/alpha/community', + transform: (r: piefed['CommunityResponse']) => ({ + ...r, + community_view: toCommunityView(r.community_view), + }), + }, + + listCommunities: { + method: 'GET', + path: '/api/alpha/community/list', + query: fromListCommunities, + transform: (r: piefed['ListCommunitiesResponse']) => ({ + communities: r.communities.map(toCommunityView), + }), + }, + + followCommunity: { + method: 'POST', + path: '/api/alpha/community/follow', + transform: (r: piefed['CommunityResponse']) => ({ + ...r, + community_view: toCommunityView(r.community_view), + }), + }, + + blockCommunity: { + method: 'POST', + path: '/api/alpha/community/block', + transform: (r: piefed['CommunityResponse'], p) => ({ + ...r, + community_view: toCommunityView(r.community_view), + blocked: p.block, + }), + }, + + deleteCommunity: { + method: 'POST', + path: '/api/alpha/community/delete', + transform: (r: piefed['CommunityResponse']) => ({ + ...r, + community_view: toCommunityView(r.community_view), + }), + }, + + banFromCommunity: async ( + client, + params: Parameters[0], + ) => { + const response = params.ban + ? await client.POST('/api/alpha/community/moderate/ban', { + body: { + community_id: params.community_id, + user_id: params.person_id, + reason: params.reason ?? 'No reason provided.', + // why is this nullable bro + expiredAt: new Date( + params.expires ?? '6767-06-07T06:07:06Z', + ).toISOString(), + } as any, + }) + : await client.PUT('/api/alpha/community/moderate/unban', { + body: { + community_id: params.community_id, + user_id: params.person_id, + } as any, + }) + + return { + banned: params.ban, + person_view: { + person: toPerson(assertData(response).banned_user!), + counts: { comment_count: -1, person_id: -1, post_count: -1 }, + is_admin: false, }, } - } - async resolveCommentReport(): ReturnType { - throw new Error('unsupported') - } - async listCommentReports(): ReturnType { - throw new Error('unsupported') - } - async getPrivateMessages( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/private_message/list', { - params: { query: params }, - }) - ).data! + }, - return { - private_messages: response.private_messages.map(toPrivateMessageView), - } - } - async createPrivateMessage( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/private_message', { body: params }) - ).data! + addModToCommunity: { + method: 'POST', + path: '/api/alpha/community/mod', + transform: transforms.moderators, + }, - return { - ...response, - private_message_view: toPrivateMessageView(response.private_message_view), - } - } - async editPrivateMessage( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.PUT('/api/alpha/private_message', { body: params }) - ).data! + search: { + method: 'GET', + path: '/api/alpha/search', + query: fromSearch, + transform: (r: piefed['SearchResponse']) => ({ + comments: [], + communities: r.communities.map(toCommunityView), + posts: r.posts.map(toPostView), + users: r.users.map(toPersonView), + type_: r.type_, + }), + }, - return { - ...response, - private_message_view: toPrivateMessageView(response.private_message_view), - } - } - async deletePrivateMessage( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/private_message/delete', { - body: params, - }) - ).data! + resolveObject: { + method: 'GET', + path: '/api/alpha/resolve_object', + query: (p) => p, + transform: (r: piefed['ResolveObjectResponse']) => ({ + // just make the rewrite options accept null values bro + comment: r.comment ? toCommentView(r.comment) : undefined, + community: r.community ? toCommunityView(r.community) : undefined, + post: r.post ? toPostView(r.post) : undefined, + person: r.person ? toPersonView(r.person) : undefined, + }), + }, - return { - ...response, - private_message_view: toPrivateMessageView(response.private_message_view), - } - } - async markPrivateMessageAsRead( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/private_message/mark_as_read', { - body: params, - }) - ).data! + getPrivateMessages: { + method: 'GET', + path: '/api/alpha/private_message/list', + query: (p) => p, + transform: (r: piefed['ListPrivateMessagesResponse']) => ({ + private_messages: r.private_messages.map(toPrivateMessageView), + }), + }, - return { - ...response, - private_message_view: toPrivateMessageView(response.private_message_view), - } - } - async createPrivateMessageReport(): ReturnType< - BaseClient['createPrivateMessageReport'] - > { - throw new Error('unsupported') - } - async resolvePrivateMessageReport(): ReturnType< - BaseClient['resolvePrivateMessageReport'] - > { - throw new Error('unsupported') - } - async listPrivateMessageReports(): ReturnType< - BaseClient['listPrivateMessageReports'] - > { - throw new Error('unsupported') - } - async register(): ReturnType { - throw new Error('unsupported') - } - async login( - params: Parameters[0], - ): ReturnType { - const response = await this.#client.POST('/api/alpha/user/login', { + createPrivateMessage: { + method: 'POST', + path: '/api/alpha/private_message', + transform: (p: piefed['PrivateMessageResponse']) => ({ + ...p, + private_message_view: toPrivateMessageView(p.private_message_view), + }), + }, + + editPrivateMessage: { + method: 'PUT', + path: '/api/alpha/private_message', + transform: (p: piefed['PrivateMessageResponse']) => ({ + ...p, + private_message_view: toPrivateMessageView(p.private_message_view), + }), + }, + + deletePrivateMessage: { + method: 'POST', + path: '/api/alpha/private_message/delete', + transform: (p: piefed['PrivateMessageResponse']) => ({ + ...p, + private_message_view: toPrivateMessageView(p.private_message_view), + }), + }, + + markPrivateMessageAsRead: { + method: 'POST', + path: '/api/alpha/private_message/mark_as_read', + transform: (p: piefed['PrivateMessageResponse']) => ({ + ...p, + private_message_view: toPrivateMessageView(p.private_message_view), + }), + }, + + login: async (client, params) => { + const response = await client.POST('/api/alpha/user/login', { body: { username: params.username_or_email, password: params.password }, - })! - + }) return { verify_email_sent: false, registration_created: false, jwt: response.data?.jwt, } - } - async logout(): ReturnType { - throw new Error('unsupported') - } - async getPersonDetails( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/user', { - params: { - query: { - ...params, - include_content: true, - sort: toSortType(params.sort), - }, - }, - }) - ).data! + }, - return { - comments: response.comments.map(toCommentView), - moderates: response.moderates.map((i) => ({ + getPersonDetails: { + method: 'GET', + path: '/api/alpha/user', + query: (p) => ({ ...p, include_content: true, sort: toSortType(p.sort) }), + transform: (r: piefed['GetUserResponse']) => ({ + comments: r.comments.map(toCommentView), + moderates: r.moderates.map((i: any) => ({ community: toCommunity(i.community), moderator: toPerson(i.moderator), })), - person_view: toPersonView(response.person_view), - posts: response.posts.map(toPostView), - } - } - async getPersonMentions( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/user/mentions', { - params: { query: { ...params, sort: toCommentSortType(params.sort) } }, - }) - ).data! + person_view: toPersonView(r.person_view), + posts: r.posts.map(toPostView), + }), + }, - return { - mentions: response.replies.map(toPersonMentionView), - } - } - async markPersonMentionAsRead( - params: Parameters[0], - ): ReturnType { - // @ts-expect-error this method isnt documented - await this.#client.POST('/api/alpha/mention/mark_as_read', { + getPersonMentions: { + method: 'GET', + path: '/api/alpha/user/mentions', + query: (p) => ({ ...p, sort: toCommentSortType(p.sort) }), + transform: (r: piefed['UserMentionsResponse']) => ({ + mentions: r.replies.map(toPersonMentionView), + }), + }, + + // current xylight has no idea why past xylight did this + markPersonMentionAsRead: async (client, params) => { + await (client as any).POST('/api/alpha/mention/mark_as_read', { body: params, }) - } - async getReplies( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.GET('/api/alpha/user/replies', { - params: { query: fromGetReplies(params) }, - }) - ).data! + }, - return { - replies: response.replies.map(toCommentReplyView), - } - } - async banPerson(): ReturnType { - // this is for site view not community view - throw new Error('unsupported') - } - async getBannedPersons(): ReturnType { - // this is for site view not community view - throw new Error('unsupported') - } - async blockPerson( - params: Parameters[0], - ): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/user/block', { body: params }) - ).data! + getReplies: { + method: 'GET', + path: '/api/alpha/user/replies', + query: fromGetReplies, + transform: (r: piefed['UserRepliesResponse']) => ({ + replies: r.replies.map(toCommentReplyView), + }), + }, - return { - ...response, - person_view: toPersonView(response.person_view), - } - } - async getCaptcha(): ReturnType { - throw new Error('unsupported') - } - async deleteAccount(): ReturnType { - throw new Error('unsupported') - } - async passwordReset(): ReturnType { - throw new Error('unsupported') - } - async passwordChangeAfterReset(): ReturnType< - BaseClient['passwordChangeAfterReset'] - > { - throw new Error('unsupported') - } - async markAllAsRead(): ReturnType { - const response = ( - await this.#client.POST('/api/alpha/user/mark_all_as_read') - ).data! + blockPerson: { + method: 'POST', + path: '/api/alpha/user/block', + transform: (r: piefed['UserBlockResponse']) => ({ + ...r, + person_view: toPersonView(r.person_view), + }), + }, - return { - replies: response.replies.map(toCommentReplyView), - } - } - async saveUserSettings( - params: Parameters[0], - ): ReturnType { - await this.#client.PUT('/api/alpha/user/save_user_settings', { - body: params, - }) - return { - success: true, - } - } - async changePassword(): ReturnType { - throw new Error('unsupported') - } - async getReportCount(): ReturnType { - throw new Error('unsupported') - } - async getUnreadCount(): ReturnType { - return (await this.#client.GET('/api/alpha/user/unread_count')).data! - } - async verifyEmail(): ReturnType { - throw new Error('unsupported') - } - async addAdmin(): ReturnType { - throw new Error('unsupported') - } - async getUnreadRegistrationApplicationCount(): ReturnType< - BaseClient['getUnreadRegistrationApplicationCount'] - > { - throw new Error('unsupported') - } - async listRegistrationApplications(): ReturnType< - BaseClient['listRegistrationApplications'] - > { - throw new Error('unsupported') - } - async approveRegistrationApplication(): ReturnType< - BaseClient['approveRegistrationApplication'] - > { - throw new Error('unsupported') - } - async getRegistrationApplication(): ReturnType< - BaseClient['getRegistrationApplication'] - > { - throw new Error('unsupported') - } - async purgePerson(): ReturnType { - throw new Error('unsupported') - } - async purgeCommunity(): ReturnType { - throw new Error('unsupported') - } - async purgePost(): ReturnType { - throw new Error('unsupported') - } - async purgeComment(): ReturnType { - throw new Error('unsupported') - } - async getFederatedInstances(): ReturnType< - BaseClient['getFederatedInstances'] - > { - return (await this.#client.GET('/api/alpha/federated_instances')).data! - } - async blockInstance( - params: Parameters[0], - ): ReturnType { - return (await this.#client.POST('/api/alpha/site/block', { - body: { ...params }, - }))!.data! - } - async uploadImage( - params: Parameters[0], - ): ReturnType { + markAllAsRead: { + method: 'POST', + path: '/api/alpha/user/mark_all_as_read', + transform: (r: piefed['UserMarkAllReadResponse']) => ({ + replies: r.replies.map(toCommentReplyView), + }), + }, + + saveUserSettings: { + method: 'PUT', + path: '/api/alpha/user/save_user_settings', + body: (p) => p, + transform: () => ({ success: true }), + }, + + getUnreadCount: { + method: 'GET', + path: '/api/alpha/user/unread_count', + transform: (r: piefed['UserUnreadCountsResponse']) => r, + }, + + setFlair: { + method: 'POST', + path: '/api/alpha/user/set_flair', + transform: (r: piefed['UserSetFlairResponse']) => ({ + ...r, + person_view: toPersonView(r.person_view!), + }), + }, + + setNote: { + method: 'POST', + path: '/api/alpha/user/note', + body: (p: types.SetNote) => ({ ...p, note: p.note ?? '' }), + transform: (r: piefed['UserSetNoteResponse']) => ({ + ...r, + person_view: toPersonView(r.person_view), + }), + }, + + getFeeds: { + method: 'GET', + path: '/api/alpha/feed/list', + query: (p: types.GetFeeds) => p, + // why is it FeedList and not ListFeeds + transform: (r: piefed['FeedListResponse']) => ({ + ...r, + feeds: r.feeds.map(toFeedView), + }), + }, + + getTopics: { + method: 'GET', + path: '/api/alpha/topic/list', + query: (p: types.GetTopics) => p, + // same here + transform: (r: piefed['TopicListResponse']) => ({ + ...r, + topics: r.topics.map(toTopicView), + }), + }, + + uploadImage: async (client, params) => { const formData = new FormData() formData.append('file', params.image as File) + const response = assertData( + await client.POST('/api/alpha/upload/image', { + body: formData as any, + }), + ) + return { ...response, msg: 'Image uploaded successfully' } + }, - const response = ( - await this.#client.POST('/api/alpha/upload/image', { - // @ts-expect-error this is the only working way to do this - body: formData, + generateTotpSecret: 'unsupported', + listLogins: 'unsupported', + listAllMedia: 'unsupported', + updateTotp: 'unsupported', + getModlog: 'unsupported', + hidePost: 'unsupported', + hideCommunity: 'unsupported', + removeCommunity: 'unsupported', + resolvePostReport: 'unsupported', + listPostReports: 'unsupported', + distinguishComment: 'unsupported', + resolveCommentReport: 'unsupported', + listCommentReports: 'unsupported', + createPrivateMessageReport: 'unsupported', + resolvePrivateMessageReport: 'unsupported', + listPrivateMessageReports: 'unsupported', + register: 'unsupported', + logout: 'unsupported', + banPerson: 'unsupported', + getBannedPersons: 'unsupported', + getCaptcha: 'unsupported', + deleteAccount: 'unsupported', + passwordReset: 'unsupported', + passwordChangeAfterReset: 'unsupported', + changePassword: 'unsupported', + getReportCount: 'unsupported', + verifyEmail: 'unsupported', + addAdmin: 'unsupported', + getUnreadRegistrationApplicationCount: 'unsupported', + listRegistrationApplications: 'unsupported', + approveRegistrationApplication: 'unsupported', + getRegistrationApplication: 'unsupported', + purgePerson: 'unsupported', + purgeCommunity: 'unsupported', + purgePost: 'unsupported', + purgeComment: 'unsupported', + editSite: 'unsupported', + deleteImage: 'unsupported', + listMedia: 'unsupported', +} satisfies MethodDefinitions + +export const PiefedClientConstants = { + password: { minLength: 6, maxLength: 128 }, +} + +async function executeMethod< + K extends MethodName, + P extends keyof paths, + M extends HttpMethod, +>( + client: ApiClient, + config: MethodConfig, + // i have been up for 3 hours writing typescript types. i am not going to be bothered to figure + // this out right before i am at the end + params: any, +): Promise { + const execute = async () => { + if (config.method === 'GET') { + return await client.GET(config.path as any, { + params: { query: config.query?.(params) ?? params }, + }) + } else { + return await (client as any)[config.method](config.path, { + body: config.body?.(params) ?? params, }) - ).data! - - return { - ...response, - msg: 'yeah it worked i think', } } - async setFlair( - params: NullableFnArg[0], - ): NullableFnReturn { - const response = ( - await this.#client.POST('/api/alpha/user/set_flair', { body: params }) - ).data! + return execute().then((response) => + config.transform(assertData(response), params), + ) +} - return toPersonView(response.person_view!) +export function createPiefedClient( + baseUrl: string, + args: { + fetchFunction: (input: any, init: any) => Promise + headers: any + }, +): BaseClient { + const client = createClient({ + baseUrl, + fetch: args.fetchFunction as any, + headers: args.headers, + }) + + const instance = { + type: { name: 'piefed', baseUrl: '/api/alpha' } as ClientType, } - async editSite(): ReturnType { - throw new Error('unsupported') - } - async deleteImage(): ReturnType { - throw new Error('unsupported') - } + return new Proxy(instance as BaseClient, { + get(target, prop: string, receiver) { + if (prop in target) return Reflect.get(target, prop, receiver) - async getFeeds( - params: NullableFnArg[0], - ): NullableFnReturn { - const response = ( - await this.#client.GET('/api/alpha/feed/list', { - params: { query: params }, - }) - ).data! + const def = methods[prop as MethodName] + if (!def) return undefined - return { - ...response, - feeds: response.feeds.map(toFeedView), - } - } + if (def === 'unsupported') { + return () => { + throw new Error(`${prop} is not supported on PieFed`) + } + } - async getTopics( - params: NullableFnArg[0], - ): NullableFnReturn { - const response = ( - await this.#client.GET('/api/alpha/topic/list', { - params: { query: params }, - }) - ).data! + if (typeof def === 'function') { + return (params: unknown) => def(client, params) + } - return { - ...response, - topics: response.topics.map(toTopicView), - } - } + return (params: unknown) => executeMethod(client, def, params) + }, + }) +} - async assignFlair( - params: NullableFnArg[0], - ): NullableFnReturn { - const response = ( - await this.#client.POST('/api/alpha/post/assign_flair', { - body: params, - }) - ).data! +export class PiefedClient { + static constants = PiefedClientConstants - return toPostView(response) - } + #proxy: BaseClient - async listMedia(): ReturnType { - throw new Error('unsupported') - } + constructor( + baseUrl: string, + args: { + fetchFunction: (input: any, init: any) => Promise + headers: any + }, + ) { + this.#proxy = createPiefedClient(baseUrl, args) - async voteOnPoll( - params: NullableFnArg[0], - ): NullableFnReturn { - const response = ( - await this.#client.POST('/api/alpha/post/poll_vote', { body: params }) - ).data! - - return toPostView(response.post_view) - } - - async setNote( - params: NullableFnArg[0], - ): NullableFnReturn { - const response = ( - await this.#client.POST('/api/alpha/user/note', { body: params }) - ).data! - - return toPersonView(response.person_view) + return new Proxy(this, { + get: (target, prop) => { + if (prop === 'constructor') return PiefedClient + return (target.#proxy as any)[prop] + }, + }) as any } } diff --git a/src/lib/api/piefed/rewrite.ts b/src/lib/api/piefed/rewrite.ts index 4e807658..9ae25b7b 100644 --- a/src/lib/api/piefed/rewrite.ts +++ b/src/lib/api/piefed/rewrite.ts @@ -1,31 +1,4 @@ -import { Search } from 'mono-svelte' -import type { - Comment, - CommentReplyView, - CommentSortType, - CommentView, - Community, - CommunityView, - CreateComment, - CreatePost, - FeedView, - GetComments, - GetPost, - GetPosts, - GetReplies, - ListCommunities, - LocalSite, - MyUserInfo, - Person, - PersonMentionView, - PersonView, - Post, - PostView, - PrivateMessageView, - SortType, - SubscribedType, - TopicView, -} from '../types' +import * as base from '../types' import type { components } from './schema' export function toPersonView( @@ -38,7 +11,7 @@ export function toPersonView( } } -export function toPerson(person: components['schemas']['Person']): Person { +export function toPerson(person: components['schemas']['Person']): base.Person { return { ...person, id: person.id, @@ -47,14 +20,16 @@ export function toPerson(person: components['schemas']['Person']): Person { } } -export function toLocalSite(site: components['schemas']['Site']): LocalSite { +export function toLocalSite( + site: components['schemas']['Site'], +): base.LocalSite { if (site) return {} return {} } export function toCommunityView( communityView: components['schemas']['CommunityView'], -): CommunityView { +): base.CommunityView { return { ...communityView, community: toCommunity(communityView.community), @@ -76,7 +51,7 @@ export function toCommunityView( export function toCommunity( community: components['schemas']['Community'], -): Community { +): base.Community { return { ...community, posting_restricted_to_mods: false, @@ -86,7 +61,7 @@ export function toCommunity( export function toMyUser( myUser: components['schemas']['MyUserInfo'], -): MyUserInfo { +): base.MyUserInfo { return { ...myUser, community_blocks: myUser.community_blocks.map((i) => ({ @@ -127,7 +102,7 @@ export function toMyUser( export function toPostView( postView: components['schemas']['PostView'], -): PostView { +): base.PostView { return { ...postView, creator: toPerson(postView.creator), @@ -149,7 +124,7 @@ export function toPost(post: components['schemas']['Post']): Post { export function toCommentView( commentView: components['schemas']['CommentView'], -): CommentView { +): base.CommentView { return { ...commentView, comment: toComment(commentView.comment), @@ -171,7 +146,7 @@ export function toComment(comment: components['schemas']['Comment']): Comment { export function toCommentReplyView( commentReplyView: components['schemas']['CommentReplyView'], -): CommentReplyView { +): base.CommentReplyView { return { ...commentReplyView, banned_from_community: false, @@ -186,7 +161,7 @@ export function toCommentReplyView( export function toPrivateMessageView( privateMessageView: components['schemas']['PrivateMessageView'], -): PrivateMessageView { +): base.PrivateMessageView { return { ...privateMessageView, creator: toPerson(privateMessageView.creator), @@ -196,7 +171,7 @@ export function toPrivateMessageView( export function toPersonMentionView( personMentionView: components['schemas']['CommentReplyView'], -): PersonMentionView { +): base.PersonMentionView { return { ...personMentionView, person_mention: personMentionView.comment_reply, @@ -212,7 +187,7 @@ export function toPersonMentionView( export function toTopicView( topicView: components['schemas']['TopicView'], -): TopicView { +): base.TopicView { return { ...topicView, communities: topicView.communities?.map(toCommunity), @@ -222,7 +197,7 @@ export function toTopicView( export function toFeedView( feedView: components['schemas']['FeedView'], -): FeedView { +): base.FeedView { return { ...feedView, communities: feedView.communities?.map(toCommunity), @@ -232,7 +207,7 @@ export function toFeedView( // Query calls export function fromGetPosts( - getPosts: GetPosts, + getPosts: base.GetPosts, ): components['parameters']['GetPosts'] { return { ...getPosts, @@ -242,7 +217,7 @@ export function fromGetPosts( } export function fromGetComments( - getComments: GetComments, + getComments: base.GetComments, ): components['schemas']['GetComments'] { return { ...getComments, @@ -251,13 +226,13 @@ export function fromGetComments( } export function fromGetPost( - getPost: GetPost, + getPost: base.GetPost, ): components['schemas']['GetPost'] { return getPost } export function fromGetReplies( - getReplies: GetReplies, + getReplies: base.GetReplies, ): components['schemas']['GetReplies'] { return { ...getReplies, @@ -265,9 +240,11 @@ export function fromGetReplies( } } -export function fromSearch(search: Search): components['schemas']['Search'] { +export function fromSearch( + search: base.Search, +): components['schemas']['Search'] { return { - ...(search as Omit & { + ...(search as Omit & { type_: 'Communities' | 'Users' | 'Url' | 'Posts' }), sort: toSortType(search.sort), @@ -275,7 +252,7 @@ export function fromSearch(search: Search): components['schemas']['Search'] { } export function fromCreatePost( - createPost: CreatePost, + createPost: base.CreatePost, ): components['schemas']['CreatePost'] { return { ...createPost, @@ -284,7 +261,7 @@ export function fromCreatePost( } export function fromListCommunities( - listCommunities: ListCommunities, + listCommunities: base.ListCommunities, ): components['schemas']['CommunityRequest'] { return { ...listCommunities, @@ -293,7 +270,7 @@ export function fromListCommunities( } export function fromCreateComment( - createComment: CreateComment, + createComment: base.CreateComment, ): components['schemas']['CreateComment'] { return { ...createComment, @@ -303,7 +280,7 @@ export function fromCreateComment( // Misc export function toSortType( - sortType?: SortType, + sortType?: base.SortType, ): components['schemas']['SortType'] | undefined { if ( sortType == 'Old' || @@ -316,14 +293,14 @@ export function toSortType( } export function toCommentSortType( - commentSortType?: CommentSortType, + commentSortType?: base.CommentSortType, ): components['schemas']['CommentSortType'] | undefined { if (commentSortType == 'Controversial') commentSortType = undefined return commentSortType } export function toCommunitiesSortType( - sortType?: SortType, + sortType?: base.SortType, ): 'Top' | 'Hot' | 'New' | undefined { if (sortType == 'Hot' || sortType == 'New' || sortType == undefined) return sortType diff --git a/src/lib/api/piefed/schema.d.ts b/src/lib/api/piefed/schema.d.ts index 07442101..c49572bf 100644 --- a/src/lib/api/piefed/schema.d.ts +++ b/src/lib/api/piefed/schema.d.ts @@ -5809,7 +5809,7 @@ export interface components { note: string } UserSetNoteResponse: { - person_view?: components['schemas']['PersonView'] + person_view: components['schemas']['PersonView'] } ListCommentsResponse: { comments: components['schemas']['CommentView'][] @@ -5873,7 +5873,7 @@ export interface components { id: number creator_id: number comment_id: number - original_comment_text?: string + original_comment_text: string reason?: string resolved: boolean /**