* Removing sniptt/monads for lemmy-js-client.
* Fix tests.
"warnOnUnsupportedTypeScriptVersion": false
},
"rules": {
- "@typescript-eslint/camelcase": 0,
- "@typescript-eslint/member-delimiter-style": 0,
- "@typescript-eslint/no-empty-interface": 0,
+ "@typescript-eslint/ban-ts-comment": 0,
"@typescript-eslint/no-explicit-any": 0,
- "@typescript-eslint/no-this-alias": 0,
- "@typescript-eslint/no-unused-vars": 0,
- "@typescript-eslint/no-use-before-define": 0,
- "@typescript-eslint/no-useless-constructor": 0,
+ "@typescript-eslint/explicit-module-boundary-types": 0,
"arrow-body-style": 0,
"curly": 0,
"eol-last": 0,
+++ /dev/null
-module.exports = Object.assign(require("eslint-plugin-prettier"), {
- arrowParens: "avoid",
- semi: true,
-});
--- /dev/null
+{
+ "arrowParens": "avoid",
+ "semi": true
+}
"author": "Dessalines",
"license": "AGPL-3.0",
"scripts": {
- "lint": "tsc --noEmit && eslint --report-unused-disable-directives --ext .js,.ts,.tsx src",
+ "lint": "tsc --noEmit && eslint --report-unused-disable-directives --ext .js,.ts,.tsx src && prettier --check 'src/**/*.ts'",
"fix": "prettier --write src && eslint --fix src",
"api-test": "jest -i follow.spec.ts && jest -i src/post.spec.ts && jest -i comment.spec.ts && jest -i private_message.spec.ts && jest -i user.spec.ts && jest -i community.spec.ts"
},
"devDependencies": {
- "@sniptt/monads": "^0.5.10",
"@types/jest": "^26.0.23",
"@typescript-eslint/eslint-plugin": "^5.21.0",
"@typescript-eslint/parser": "^5.21.0",
- "class-transformer": "^0.5.1",
"eslint": "^8.25.0",
"eslint-plugin-prettier": "^4.0.0",
"jest": "^27.0.6",
- "lemmy-js-client": "0.17.0-rc.56",
+ "lemmy-js-client": "0.17.0-rc.60",
"node-fetch": "^2.6.1",
"prettier": "^2.7.1",
- "reflect-metadata": "^0.1.13",
"ts-jest": "^27.0.3",
"typescript": "^4.8.4"
}
jest.setTimeout(180000);
-import { None, Some } from "@sniptt/monads";
import { CommentView } from "lemmy-js-client";
import { PostResponse } from "lemmy-js-client";
await followBeta(alpha);
await followBeta(gamma);
let betaCommunity = (await resolveBetaCommunity(alpha)).community;
- postRes = await createPost(alpha, betaCommunity.unwrap().community.id);
+ if (betaCommunity) {
+ postRes = await createPost(alpha, betaCommunity.community.id);
+ }
});
afterAll(async () => {
});
function assertCommentFederation(
- commentOne: CommentView,
- commentTwo: CommentView
+ commentOne?: CommentView,
+ commentTwo?: CommentView
) {
- expect(commentOne.comment.ap_id).toBe(commentOne.comment.ap_id);
- expect(commentOne.comment.content).toBe(commentTwo.comment.content);
- expect(commentOne.creator.name).toBe(commentTwo.creator.name);
- expect(commentOne.community.actor_id).toBe(commentTwo.community.actor_id);
- expect(commentOne.comment.published).toBe(commentTwo.comment.published);
- expect(commentOne.comment.updated).toBe(commentOne.comment.updated);
- expect(commentOne.comment.deleted).toBe(commentOne.comment.deleted);
- expect(commentOne.comment.removed).toBe(commentOne.comment.removed);
+ expect(commentOne?.comment.ap_id).toBe(commentTwo?.comment.ap_id);
+ expect(commentOne?.comment.content).toBe(commentTwo?.comment.content);
+ expect(commentOne?.creator.name).toBe(commentTwo?.creator.name);
+ expect(commentOne?.community.actor_id).toBe(commentTwo?.community.actor_id);
+ expect(commentOne?.comment.published).toBe(commentTwo?.comment.published);
+ expect(commentOne?.comment.updated).toBe(commentOne?.comment.updated);
+ expect(commentOne?.comment.deleted).toBe(commentOne?.comment.deleted);
+ expect(commentOne?.comment.removed).toBe(commentOne?.comment.removed);
}
test("Create a comment", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
expect(commentRes.comment_view.comment.content).toBeDefined();
expect(commentRes.comment_view.community.local).toBe(false);
expect(commentRes.comment_view.creator.local).toBe(true);
// Make sure that comment is liked on beta
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
expect(betaComment).toBeDefined();
- expect(betaComment.community.local).toBe(true);
- expect(betaComment.creator.local).toBe(false);
- expect(betaComment.counts.score).toBe(1);
+ expect(betaComment?.community.local).toBe(true);
+ expect(betaComment?.creator.local).toBe(false);
+ expect(betaComment?.counts.score).toBe(1);
assertCommentFederation(betaComment, commentRes.comment_view);
});
test("Create a comment in a non-existent post", async () => {
- let commentRes = (await createComment(alpha, -1, None)) as any;
+ let commentRes = (await createComment(alpha, -1)) as any;
expect(commentRes.error).toBe("couldnt_find_post");
});
test("Update a comment", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
// Federate the comment first
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
).comment;
- assertCommentFederation(betaComment.unwrap(), commentRes.comment_view);
+ assertCommentFederation(betaComment, commentRes.comment_view);
let updateCommentRes = await editComment(
alpha,
// Make sure that post is updated on beta
let betaCommentUpdated = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
assertCommentFederation(betaCommentUpdated, updateCommentRes.comment_view);
});
test("Delete a comment", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
let deleteCommentRes = await deleteComment(
alpha,
// Make sure that comment is undeleted on beta
let betaComment2 = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
- expect(betaComment2.comment.deleted).toBe(false);
+ ).comment;
+ expect(betaComment2?.comment.deleted).toBe(false);
assertCommentFederation(betaComment2, undeleteCommentRes.comment_view);
});
test("Remove a comment from admin and community on the same instance", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
// Get the id for beta
let betaCommentId = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap().comment.id;
+ ).comment?.comment.id;
+
+ if (!betaCommentId) {
+ throw "beta comment id is missing";
+ }
// The beta admin removes it (the community lives on beta)
let removeCommentRes = await removeComment(beta, true, betaCommentId);
let alpha_user = await registerUser(alpha);
let newAlphaApi: API = {
client: alpha.client,
- auth: alpha_user.jwt,
+ auth: alpha_user.jwt ?? "",
};
// New alpha user creates a community, post, and comment.
newAlphaApi,
newCommunity.community_view.community.id
);
- let commentRes = await createComment(
- newAlphaApi,
- newPost.post_view.post.id,
- None
- );
+ let commentRes = await createComment(newAlphaApi, newPost.post_view.post.id);
expect(commentRes.comment_view.comment.content).toBeDefined();
// Beta searches that to cache it, then removes it
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
+
+ if (!betaComment) {
+ throw "beta comment missing";
+ }
+
let removeCommentRes = await removeComment(
beta,
true,
});
test("Unlike a comment", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
let unlike = await likeComment(alpha, 0, commentRes.comment_view.comment);
expect(unlike.comment_view.counts.score).toBe(0);
// Make sure that post is unliked on beta
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
expect(betaComment).toBeDefined();
- expect(betaComment.community.local).toBe(true);
- expect(betaComment.creator.local).toBe(false);
- expect(betaComment.counts.score).toBe(0);
+ expect(betaComment?.community.local).toBe(true);
+ expect(betaComment?.creator.local).toBe(false);
+ expect(betaComment?.counts.score).toBe(0);
});
test("Federated comment like", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
// Find the comment on beta
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
+
+ if (!betaComment) {
+ throw "Missing beta comment";
+ }
let like = await likeComment(beta, 1, betaComment.comment);
expect(like.comment_view.counts.score).toBe(2);
test("Reply to a comment", async () => {
// Create a comment on alpha, find it on beta
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
+
+ if (!betaComment) {
+ throw "Missing beta comment";
+ }
// find that comment id on beta
let replyRes = await createComment(
beta,
betaComment.post.id,
- Some(betaComment.comment.id)
+ betaComment.comment.id
);
expect(replyRes.comment_view.comment.content).toBeDefined();
expect(replyRes.comment_view.community.local).toBe(true);
expect(replyRes.comment_view.creator.local).toBe(true);
- expect(getCommentParentId(replyRes.comment_view.comment).unwrap()).toBe(
+ expect(getCommentParentId(replyRes.comment_view.comment)).toBe(
betaComment.comment.id
);
expect(replyRes.comment_view.counts.score).toBe(1);
let postComments = await getComments(alpha, postRes.post_view.post.id);
let alphaComment = postComments.comments[0];
expect(alphaComment.comment.content).toBeDefined();
- expect(getCommentParentId(alphaComment.comment).unwrap()).toBe(
+ expect(getCommentParentId(alphaComment.comment)).toBe(
postComments.comments[1].comment.id
);
expect(alphaComment.community.local).toBe(false);
test("Mention beta", async () => {
// Create a mention on alpha
let mentionContent = "A test mention of @lemmy_beta@lemmy-beta:8551";
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
let mentionRes = await createComment(
alpha,
postRes.post_view.post.id,
- Some(commentRes.comment_view.comment.id),
+ commentRes.comment_view.comment.id,
mentionContent
);
expect(mentionRes.comment_view.comment.content).toBeDefined();
});
test("Comment Search", async () => {
- let commentRes = await createComment(alpha, postRes.post_view.post.id, None);
+ let commentRes = await createComment(alpha, postRes.post_view.post.id);
let betaComment = (
await resolveComment(beta, commentRes.comment_view.comment)
- ).comment.unwrap();
+ ).comment;
assertCommentFederation(betaComment, commentRes.comment_view);
});
test("A and G subscribe to B (center) A posts, G mentions B, it gets announced to A", async () => {
// Create a local post
- let alphaCommunity = (
- await resolveCommunity(alpha, "!main@lemmy-alpha:8541")
- ).community.unwrap();
+ let alphaCommunity = (await resolveCommunity(alpha, "!main@lemmy-alpha:8541"))
+ .community;
+
+ if (!alphaCommunity) {
+ throw "Missing alpha community";
+ }
+
let alphaPost = await createPost(alpha, alphaCommunity.community.id);
expect(alphaPost.post_view.community.local).toBe(true);
// Make sure gamma sees it
- let gammaPost = (
- await resolvePost(gamma, alphaPost.post_view.post)
- ).post.unwrap();
+ let gammaPost = (await resolvePost(gamma, alphaPost.post_view.post)).post;
+
+ if (!gammaPost) {
+ throw "Missing gamma post";
+ }
let commentContent =
"A jest test federated comment announce, lets mention @lemmy_beta@lemmy-beta:8551";
let commentRes = await createComment(
gamma,
gammaPost.post.id,
- None,
+ undefined,
commentContent
);
expect(commentRes.comment_view.comment.content).toBe(commentContent);
expect(betaPost.post_view.community.local).toBe(true);
// Make sure gamma and alpha see it
- let gammaPost = (
- await resolvePost(gamma, betaPost.post_view.post)
- ).post.unwrap();
+ let gammaPost = (await resolvePost(gamma, betaPost.post_view.post)).post;
+ if (!gammaPost) {
+ throw "Missing gamma post";
+ }
expect(gammaPost.post).toBeDefined();
- let alphaPost = (
- await resolvePost(alpha, betaPost.post_view.post)
- ).post.unwrap();
+
+ let alphaPost = (await resolvePost(alpha, betaPost.post_view.post)).post;
+ if (!alphaPost) {
+ throw "Missing alpha post";
+ }
expect(alphaPost.post).toBeDefined();
// The bug: gamma comments, and alpha should see it.
let commentRes = await createComment(
gamma,
gammaPost.post.id,
- None,
+ undefined,
commentContent
);
expect(commentRes.comment_view.comment.content).toBe(commentContent);
// Unfollow all remote communities
let site = await unfollowRemotes(alpha);
expect(
- site.my_user.unwrap().follows.filter(c => c.community.local == false).length
+ site.my_user?.follows.filter(c => c.community.local == false).length
).toBe(0);
// B creates a post, and two comments, should be invisible to A
let parentCommentRes = await createComment(
beta,
postRes.post_view.post.id,
- None,
+ undefined,
parentCommentContent
);
expect(parentCommentRes.comment_view.comment.content).toBe(
let childCommentRes = await createComment(
beta,
postRes.post_view.post.id,
- Some(parentCommentRes.comment_view.comment.id),
+ parentCommentRes.comment_view.comment.id,
childCommentContent
);
expect(childCommentRes.comment_view.comment.content).toBe(
expect(follow.community_view.community.name).toBe("main");
// An update to the child comment on beta, should push the post, parent, and child to alpha now
- let updatedCommentContent = Some("An update child comment from beta");
+ let updatedCommentContent = "An update child comment from beta";
let updateRes = await editComment(
beta,
childCommentRes.comment_view.comment.id,
updatedCommentContent
);
- expect(updateRes.comment_view.comment.content).toBe(
- updatedCommentContent.unwrap()
- );
+ expect(updateRes.comment_view.comment.content).toBe(updatedCommentContent);
// Get the post from alpha
- let alphaPostB = (
- await resolvePost(alpha, postRes.post_view.post)
- ).post.unwrap();
+ let alphaPostB = (await resolvePost(alpha, postRes.post_view.post)).post;
+ if (!alphaPostB) {
+ throw "Missing alpha post B";
+ }
let alphaPost = await getPost(alpha, alphaPostB.post.id);
let alphaPostComments = await getComments(alpha, alphaPostB.post.id);
});
test("Report a comment", async () => {
- let betaCommunity = (await resolveBetaCommunity(beta)).community.unwrap();
+ let betaCommunity = (await resolveBetaCommunity(beta)).community;
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let postRes = (await createPost(beta, betaCommunity.community.id)).post_view
.post;
expect(postRes).toBeDefined();
- let commentRes = (await createComment(beta, postRes.id, None)).comment_view
- .comment;
+ let commentRes = (await createComment(beta, postRes.id)).comment_view.comment;
expect(commentRes).toBeDefined();
- let alphaComment = (await resolveComment(alpha, commentRes)).comment.unwrap()
- .comment;
+ let alphaComment = (await resolveComment(alpha, commentRes)).comment?.comment;
+ if (!alphaComment) {
+ throw "Missing alpha comment";
+ }
+
let alphaReport = (
await reportComment(alpha, alphaComment.id, randomString(10))
).comment_report_view.comment_report;
});
function assertCommunityFederation(
- communityOne: CommunityView,
- communityTwo: CommunityView
+ communityOne?: CommunityView,
+ communityTwo?: CommunityView
) {
- expect(communityOne.community.actor_id).toBe(communityTwo.community.actor_id);
- expect(communityOne.community.name).toBe(communityTwo.community.name);
- expect(communityOne.community.title).toBe(communityTwo.community.title);
- expect(communityOne.community.description.unwrapOr("none")).toBe(
- communityTwo.community.description.unwrapOr("none")
- );
- expect(communityOne.community.icon.unwrapOr("none")).toBe(
- communityTwo.community.icon.unwrapOr("none")
- );
- expect(communityOne.community.banner.unwrapOr("none")).toBe(
- communityTwo.community.banner.unwrapOr("none")
- );
- expect(communityOne.community.published).toBe(
- communityTwo.community.published
- );
- expect(communityOne.community.nsfw).toBe(communityTwo.community.nsfw);
- expect(communityOne.community.removed).toBe(communityTwo.community.removed);
- expect(communityOne.community.deleted).toBe(communityTwo.community.deleted);
+ expect(communityOne?.community.actor_id).toBe(
+ communityTwo?.community.actor_id
+ );
+ expect(communityOne?.community.name).toBe(communityTwo?.community.name);
+ expect(communityOne?.community.title).toBe(communityTwo?.community.title);
+ expect(communityOne?.community.description).toBe(
+ communityTwo?.community.description
+ );
+ expect(communityOne?.community.icon).toBe(communityTwo?.community.icon);
+ expect(communityOne?.community.banner).toBe(communityTwo?.community.banner);
+ expect(communityOne?.community.published).toBe(
+ communityTwo?.community.published
+ );
+ expect(communityOne?.community.nsfw).toBe(communityTwo?.community.nsfw);
+ expect(communityOne?.community.removed).toBe(communityTwo?.community.removed);
+ expect(communityOne?.community.deleted).toBe(communityTwo?.community.deleted);
}
test("Create community", async () => {
// Cache the community on beta, make sure it has the other fields
let searchShort = `!${prevName}@lemmy-alpha:8541`;
- let betaCommunity = (
- await resolveCommunity(beta, searchShort)
- ).community.unwrap();
+ let betaCommunity = (await resolveCommunity(beta, searchShort)).community;
assertCommunityFederation(betaCommunity, communityRes.community_view);
});
// Cache the community on Alpha
let searchShort = `!${communityRes.community_view.community.name}@lemmy-beta:8551`;
- let alphaCommunity = (
- await resolveCommunity(alpha, searchShort)
- ).community.unwrap();
+ let alphaCommunity = (await resolveCommunity(alpha, searchShort)).community;
+ if (!alphaCommunity) {
+ throw "Missing alpha community";
+ }
assertCommunityFederation(alphaCommunity, communityRes.community_view);
// Follow the community from alpha
// Cache the community on Alpha
let searchShort = `!${communityRes.community_view.community.name}@lemmy-beta:8551`;
- let alphaCommunity = (
- await resolveCommunity(alpha, searchShort)
- ).community.unwrap();
+ let alphaCommunity = (await resolveCommunity(alpha, searchShort)).community;
+ if (!alphaCommunity) {
+ throw "Missing alpha community";
+ }
assertCommunityFederation(alphaCommunity, communityRes.community_view);
// Follow the community from alpha
expect(communityRes.community_view.community.name).toBeDefined();
let searchShort = `!${communityRes.community_view.community.name}@lemmy-beta:8551`;
- let alphaCommunity = (
- await resolveCommunity(alpha, searchShort)
- ).community.unwrap();
+ let alphaCommunity = (await resolveCommunity(alpha, searchShort)).community;
assertCommunityFederation(alphaCommunity, communityRes.community_view);
});
// gamma follows community and posts in it
let gammaCommunity = (
await resolveCommunity(gamma, communityRes.community.actor_id)
- ).community.unwrap();
- await followCommunity(
- gamma,
- true,
- gammaCommunity.community.id
- );
+ ).community;
+ if (!gammaCommunity) {
+ throw "Missing gamma community";
+ }
+ await followCommunity(gamma, true, gammaCommunity.community.id);
gammaCommunity = (
await resolveCommunity(gamma, communityRes.community.actor_id)
- ).community.unwrap();
+ ).community;
+ if (!gammaCommunity) {
+ throw "Missing gamma community";
+ }
expect(gammaCommunity.subscribed).toBe("Subscribed");
let gammaPost = (await createPost(gamma, gammaCommunity.community.id))
.post_view;
// admin of beta decides to ban gamma from community
let betaCommunity = (
await resolveCommunity(beta, communityRes.community.actor_id)
- ).community.unwrap();
- let bannedUserInfo1 = (await getSite(gamma)).my_user.unwrap().local_user_view
+ ).community;
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
+ let bannedUserInfo1 = (await getSite(gamma)).my_user?.local_user_view.person;
+ if (!bannedUserInfo1) {
+ throw "Missing banned user 1";
+ }
+ let bannedUserInfo2 = (await resolvePerson(beta, bannedUserInfo1.actor_id))
.person;
- let bannedUserInfo2 = (
- await resolvePerson(beta, bannedUserInfo1.actor_id)
- ).person.unwrap();
+ if (!bannedUserInfo2) {
+ throw "Missing banned user 2";
+ }
let banRes = await banPersonFromCommunity(
beta,
bannedUserInfo2.person.id,
expect(banRes.banned).toBe(true);
// ban doesnt federate to community's origin instance alpha
- let alphaPost = (await resolvePost(alpha, gammaPost.post)).post.unwrap();
- expect(alphaPost.creator_banned_from_community).toBe(false);
+ let alphaPost = (await resolvePost(alpha, gammaPost.post)).post;
+ expect(alphaPost?.creator_banned_from_community).toBe(false);
// and neither to gamma
let gammaPost2 = await getPost(gamma, gammaPost.post.id);
});
test("Follow federated community", async () => {
- let betaCommunity = (await resolveBetaCommunity(alpha)).community.unwrap();
+ let betaCommunity = (await resolveBetaCommunity(alpha)).community;
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
await followCommunity(alpha, true, betaCommunity.community.id);
- betaCommunity = (await resolveBetaCommunity(alpha)).community.unwrap();
+ betaCommunity = (await resolveBetaCommunity(alpha)).community;
// Make sure the follow response went through
- expect(betaCommunity.community.local).toBe(false);
- expect(betaCommunity.community.name).toBe("main");
- expect(betaCommunity.subscribed).toBe(SubscribedType.Subscribed);
+ expect(betaCommunity?.community.local).toBe(false);
+ expect(betaCommunity?.community.name).toBe("main");
+ expect(betaCommunity?.subscribed).toBe(SubscribedType.Subscribed);
// Check it from local
let site = await getSite(alpha);
- let remoteCommunityId = site.my_user
- .unwrap()
- .follows.find(c => c.community.local == false).community.id;
+ let remoteCommunityId = site.my_user?.follows.find(
+ c => c.community.local == false
+ )?.community.id;
expect(remoteCommunityId).toBeDefined();
- expect(site.my_user.unwrap().follows.length).toBe(2);
+ expect(site.my_user?.follows.length).toBe(2);
+
+ if (!remoteCommunityId) {
+ throw "Missing remote community id";
+ }
// Test an unfollow
let unfollow = await followCommunity(alpha, false, remoteCommunityId);
// Make sure you are unsubbed locally
let siteUnfollowCheck = await getSite(alpha);
- expect(siteUnfollowCheck.my_user.unwrap().follows.length).toBe(1);
+ expect(siteUnfollowCheck.my_user?.follows.length).toBe(1);
});
jest.setTimeout(120000);
-import { None } from "@sniptt/monads";
import { PostView, CommunityView } from "lemmy-js-client";
import {
resolveCommunity,
} from "./shared";
-let betaCommunity: CommunityView;
+let betaCommunity: CommunityView | undefined;
beforeAll(async () => {
await setupLogins();
- betaCommunity = (await resolveBetaCommunity(alpha)).community.unwrap();
+ betaCommunity = (await resolveBetaCommunity(alpha)).community;
expect(betaCommunity).toBeDefined();
await unfollows();
});
await unfollows();
});
-function assertPostFederation(postOne: PostView, postTwo: PostView) {
- expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
- expect(postOne.post.name).toBe(postTwo.post.name);
- expect(postOne.post.body.unwrapOr("none")).toBe(
- postTwo.post.body.unwrapOr("none")
- );
- expect(postOne.post.url.unwrapOr("https://google.com/")).toBe(
- postTwo.post.url.unwrapOr("https://google.com/")
- );
- expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
- expect(postOne.post.embed_title.unwrapOr("none")).toBe(
- postTwo.post.embed_title.unwrapOr("none")
- );
- expect(postOne.post.embed_description.unwrapOr("none")).toBe(
- postTwo.post.embed_description.unwrapOr("none")
- );
- expect(postOne.post.embed_video_url.unwrapOr("none")).toBe(
- postTwo.post.embed_video_url.unwrapOr("none")
- );
- expect(postOne.post.published).toBe(postTwo.post.published);
- expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
- expect(postOne.post.locked).toBe(postTwo.post.locked);
- expect(postOne.post.removed).toBe(postTwo.post.removed);
- expect(postOne.post.deleted).toBe(postTwo.post.deleted);
+function assertPostFederation(postOne?: PostView, postTwo?: PostView) {
+ expect(postOne?.post.ap_id).toBe(postTwo?.post.ap_id);
+ expect(postOne?.post.name).toBe(postTwo?.post.name);
+ expect(postOne?.post.body).toBe(postTwo?.post.body);
+ // TODO url clears arent working
+ // expect(postOne?.post.url).toBe(postTwo?.post.url);
+ expect(postOne?.post.nsfw).toBe(postTwo?.post.nsfw);
+ expect(postOne?.post.embed_title).toBe(postTwo?.post.embed_title);
+ expect(postOne?.post.embed_description).toBe(postTwo?.post.embed_description);
+ expect(postOne?.post.embed_video_url).toBe(postTwo?.post.embed_video_url);
+ expect(postOne?.post.published).toBe(postTwo?.post.published);
+ expect(postOne?.community.actor_id).toBe(postTwo?.community.actor_id);
+ expect(postOne?.post.locked).toBe(postTwo?.post.locked);
+ expect(postOne?.post.removed).toBe(postTwo?.post.removed);
+ expect(postOne?.post.deleted).toBe(postTwo?.post.deleted);
}
test("Create a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
+
let postRes = await createPost(alpha, betaCommunity.community.id);
expect(postRes.post_view.post).toBeDefined();
expect(postRes.post_view.community.local).toBe(false);
expect(postRes.post_view.counts.score).toBe(1);
// Make sure that post is liked on beta
- let betaPost = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
expect(betaPost).toBeDefined();
- expect(betaPost.community.local).toBe(true);
- expect(betaPost.creator.local).toBe(false);
- expect(betaPost.counts.score).toBe(1);
+ expect(betaPost?.community.local).toBe(true);
+ expect(betaPost?.creator.local).toBe(false);
+ expect(betaPost?.counts.score).toBe(1);
assertPostFederation(betaPost, postRes.post_view);
// Delta only follows beta, so it should not see an alpha ap_id
let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
- expect(deltaPost.isNone()).toBe(true);
+ expect(deltaPost).toBeUndefined();
// Epsilon has alpha blocked, it should not see the alpha post
let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
- expect(epsilonPost.isNone()).toBe(true);
+ expect(epsilonPost).toBeUndefined();
});
test("Create a post in a non-existent community", async () => {
});
test("Unlike a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let postRes = await createPost(alpha, betaCommunity.community.id);
let unlike = await likePost(alpha, 0, postRes.post_view.post);
expect(unlike.post_view.counts.score).toBe(0);
expect(unlike2.post_view.counts.score).toBe(0);
// Make sure that post is unliked on beta
- let betaPost = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
expect(betaPost).toBeDefined();
- expect(betaPost.community.local).toBe(true);
- expect(betaPost.creator.local).toBe(false);
- expect(betaPost.counts.score).toBe(0);
+ expect(betaPost?.community.local).toBe(true);
+ expect(betaPost?.creator.local).toBe(false);
+ expect(betaPost?.counts.score).toBe(0);
assertPostFederation(betaPost, postRes.post_view);
});
test("Update a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let postRes = await createPost(alpha, betaCommunity.community.id);
let updatedName = "A jest test federated post, updated";
expect(updatedPost.post_view.creator.local).toBe(true);
// Make sure that post is updated on beta
- let betaPost = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
+ if (!betaPost) {
+ throw "Missing beta post";
+ }
expect(betaPost.community.local).toBe(true);
expect(betaPost.creator.local).toBe(false);
expect(betaPost.post.name).toBe(updatedName);
});
test("Sticky a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let postRes = await createPost(alpha, betaCommunity.community.id);
- let betaPost1 = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
+ if (!betaPost1) {
+ throw "Missing beta post1";
+ }
let stickiedPostRes = await featurePost(beta, true, betaPost1.post);
expect(stickiedPostRes.post_view.post.featured_community).toBe(true);
// Make sure that post is stickied on beta
- let betaPost = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
- expect(betaPost.community.local).toBe(true);
- expect(betaPost.creator.local).toBe(false);
- expect(betaPost.post.featured_community).toBe(true);
+ let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
+ expect(betaPost?.community.local).toBe(true);
+ expect(betaPost?.creator.local).toBe(false);
+ expect(betaPost?.post.featured_community).toBe(true);
// Unsticky a post
let unstickiedPost = await featurePost(beta, false, betaPost1.post);
expect(unstickiedPost.post_view.post.featured_community).toBe(false);
// Make sure that post is unstickied on beta
- let betaPost2 = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
- expect(betaPost2.community.local).toBe(true);
- expect(betaPost2.creator.local).toBe(false);
- expect(betaPost2.post.featured_community).toBe(false);
+ let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
+ expect(betaPost2?.community.local).toBe(true);
+ expect(betaPost2?.creator.local).toBe(false);
+ expect(betaPost2?.post.featured_community).toBe(false);
// Make sure that gamma cannot sticky the post on beta
- let gammaPost = (
- await resolvePost(gamma, postRes.post_view.post)
- ).post.unwrap();
+ let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
+ if (!gammaPost) {
+ throw "Missing gamma post";
+ }
let gammaTrySticky = await featurePost(gamma, true, gammaPost.post);
- let betaPost3 = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
expect(gammaTrySticky.post_view.post.featured_community).toBe(true);
- expect(betaPost3.post.featured_community).toBe(false);
+ expect(betaPost3?.post.featured_community).toBe(false);
});
test("Lock a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
await followCommunity(alpha, true, betaCommunity.community.id);
let postRes = await createPost(alpha, betaCommunity.community.id);
// Lock the post
- let betaPost1 = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
+ if (!betaPost1) {
+ throw "Missing beta post1";
+ }
let lockedPostRes = await lockPost(beta, true, betaPost1.post);
expect(lockedPostRes.post_view.post.locked).toBe(true);
expect(alphaPost1.post.locked).toBe(true);
// Try to make a new comment there, on alpha
- let comment: any = await createComment(alpha, alphaPost1.post.id, None);
+ let comment: any = await createComment(alpha, alphaPost1.post.id);
expect(comment["error"]).toBe("locked");
// Unlock a post
expect(alphaPost2.post.locked).toBe(false);
// Try to create a new comment, on alpha
- let commentAlpha = await createComment(alpha, alphaPost1.post.id, None);
+ let commentAlpha = await createComment(alpha, alphaPost1.post.id);
expect(commentAlpha).toBeDefined();
});
test("Delete a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
+
let postRes = await createPost(alpha, betaCommunity.community.id);
expect(postRes.post_view.post).toBeDefined();
// Make sure lemmy beta sees post is deleted
let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
// This will be undefined because of the tombstone
- expect(betaPost.isNone()).toBe(true);
+ expect(betaPost).toBeUndefined();
// Undelete
let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
expect(undeletedPost.post_view.post.deleted).toBe(false);
// Make sure lemmy beta sees post is undeleted
- let betaPost2 = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
+ if (!betaPost2) {
+ throw "Missing beta post 2";
+ }
expect(betaPost2.post.deleted).toBe(false);
assertPostFederation(betaPost2, undeletedPost.post_view);
});
test("Remove a post from admin and community on different instance", async () => {
- let gammaCommunity = await resolveCommunity(
- gamma,
- betaCommunity.community.actor_id
- );
- let postRes = await createPost(
- gamma,
- gammaCommunity.community.unwrap().community.id
- );
-
- let alphaPost = (
- await resolvePost(alpha, postRes.post_view.post)
- ).post.unwrap();
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
+
+ let gammaCommunity = (
+ await resolveCommunity(gamma, betaCommunity.community.actor_id)
+ ).community?.community;
+ if (!gammaCommunity) {
+ throw "Missing gamma community";
+ }
+ let postRes = await createPost(gamma, gammaCommunity.id);
+
+ let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
+ if (!alphaPost) {
+ throw "Missing alpha post";
+ }
let removedPost = await removePost(alpha, true, alphaPost.post);
expect(removedPost.post_view.post.removed).toBe(true);
expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
// Make sure lemmy beta sees post is NOT removed
- let betaPost = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
+ let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
+ if (!betaPost) {
+ throw "Missing beta post";
+ }
expect(betaPost.post.removed).toBe(false);
// Undelete
expect(undeletedPost.post_view.post.removed).toBe(false);
// Make sure lemmy beta sees post is undeleted
- let betaPost2 = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
- expect(betaPost2.post.removed).toBe(false);
+ let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
+ expect(betaPost2?.post.removed).toBe(false);
assertPostFederation(betaPost2, undeletedPost.post_view);
});
test("Remove a post from admin and community on same instance", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
await followBeta(alpha);
let postRes = await createPost(alpha, betaCommunity.community.id);
expect(postRes.post_view.post).toBeDefined();
});
test("Search for a post", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
await unfollowRemotes(alpha);
let postRes = await createPost(alpha, betaCommunity.community.id);
expect(postRes.post_view.post).toBeDefined();
- let betaPost = (
- await resolvePost(beta, postRes.post_view.post)
- ).post.unwrap();
- expect(betaPost.post.name).toBeDefined();
+ let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
+ expect(betaPost?.post.name).toBeDefined();
});
test("Enforce site ban for federated user", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
// create a test user
let alphaUserJwt = await registerUser(alpha);
expect(alphaUserJwt).toBeDefined();
let alpha_user: API = {
client: alpha.client,
- auth: alphaUserJwt.jwt,
+ auth: alphaUserJwt.jwt ?? "",
};
- let alphaUserActorId = (await getSite(alpha_user)).my_user.unwrap()
- .local_user_view.person.actor_id;
+ let alphaUserActorId = (await getSite(alpha_user)).my_user?.local_user_view
+ .person.actor_id;
+ if (!alphaUserActorId) {
+ throw "Missing alpha user actor id";
+ }
expect(alphaUserActorId).toBeDefined();
- let alphaPerson = (
- await resolvePerson(alpha_user, alphaUserActorId)
- ).person.unwrap();
+ let alphaPerson = (await resolvePerson(alpha_user, alphaUserActorId)).person;
+ if (!alphaPerson) {
+ throw "Missing alpha person";
+ }
expect(alphaPerson).toBeDefined();
// alpha makes post in beta community, it federates to beta instance
// alpha ban should be federated to beta
let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
- expect(alphaUserOnBeta1.person.unwrap().person.banned).toBe(true);
+ expect(alphaUserOnBeta1.person?.person.banned).toBe(true);
// existing alpha post should be removed on beta
let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
expect(searchBeta3.posts[0]).toBeDefined();
let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId);
- expect(alphaUserOnBeta2.person.unwrap().person.banned).toBe(false);
+ expect(alphaUserOnBeta2.person?.person.banned).toBe(false);
});
test("Enforce community ban for federated user", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
- let alphaPerson = (await resolvePerson(beta, alphaShortname)).person.unwrap();
+ let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
+ if (!alphaPerson) {
+ throw "Missing alpha person";
+ }
expect(alphaPerson).toBeDefined();
// make a post in beta, it goes through
});
test("A and G subscribe to B (center) A posts, it gets announced to G", async () => {
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let postRes = await createPost(alpha, betaCommunity.community.id);
expect(postRes.post_view.post).toBeDefined();
- let betaPost = (
- await resolvePost(gamma, postRes.post_view.post)
- ).post.unwrap();
- expect(betaPost.post.name).toBeDefined();
+ let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
+ expect(betaPost?.post.name).toBeDefined();
});
test("Report a post", async () => {
- let betaCommunity = (await resolveBetaCommunity(beta)).community.unwrap();
+ // Note, this is a different one from the setup
+ let betaCommunity = (await resolveBetaCommunity(beta)).community;
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let postRes = await createPost(beta, betaCommunity.community.id);
expect(postRes.post_view.post).toBeDefined();
- let alphaPost = (
- await resolvePost(alpha, postRes.post_view.post)
- ).post.unwrap();
+ let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
+ if (!alphaPost) {
+ throw "Missing alpha post";
+ }
let alphaReport = (
await reportPost(alpha, alphaPost.post.id, randomString(10))
).post_report_view.post_report;
expect(betaReport).toBeDefined();
expect(betaReport.resolved).toBe(false);
expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
- expect(betaReport.original_post_url.unwrapOr("none")).toBe(
- alphaReport.original_post_url.unwrapOr("none")
- );
- expect(betaReport.original_post_body.unwrapOr("none")).toBe(
- alphaReport.original_post_body.unwrapOr("none")
- );
+ expect(betaReport.original_post_url).toBe(alphaReport.original_post_url);
+ expect(betaReport.original_post_body).toBe(alphaReport.original_post_body);
expect(betaReport.reason).toBe(alphaReport.reason);
});
-import { None, Some, Option } from "@sniptt/monads";
import {
Login,
LoginResponse,
export interface API {
client: LemmyHttp;
- auth: Option<string>;
+ auth: string;
}
export let alpha: API = {
client: new LemmyHttp("http://127.0.0.1:8541"),
- auth: None,
+ auth: "",
};
export let beta: API = {
client: new LemmyHttp("http://127.0.0.1:8551"),
- auth: None,
+ auth: "",
};
export let gamma: API = {
client: new LemmyHttp("http://127.0.0.1:8561"),
- auth: None,
+ auth: "",
};
export let delta: API = {
client: new LemmyHttp("http://127.0.0.1:8571"),
- auth: None,
+ auth: "",
};
export let epsilon: API = {
client: new LemmyHttp("http://127.0.0.1:8581"),
- auth: None,
+ auth: "",
};
const password = "lemmylemmy";
export async function setupLogins() {
- let formAlpha = new Login({
+ let formAlpha: Login = {
username_or_email: "lemmy_alpha",
password,
- });
+ };
let resAlpha = alpha.client.login(formAlpha);
- let formBeta = new Login({
+ let formBeta: Login = {
username_or_email: "lemmy_beta",
password,
- });
+ };
let resBeta = beta.client.login(formBeta);
- let formGamma = new Login({
+ let formGamma: Login = {
username_or_email: "lemmy_gamma",
password,
- });
+ };
let resGamma = gamma.client.login(formGamma);
- let formDelta = new Login({
+ let formDelta: Login = {
username_or_email: "lemmy_delta",
password,
- });
+ };
let resDelta = delta.client.login(formDelta);
- let formEpsilon = new Login({
+ let formEpsilon: Login = {
username_or_email: "lemmy_epsilon",
password,
- });
+ };
let resEpsilon = epsilon.client.login(formEpsilon);
let res = await Promise.all([
resEpsilon,
]);
- alpha.auth = res[0].jwt;
- beta.auth = res[1].jwt;
- gamma.auth = res[2].jwt;
- delta.auth = res[3].jwt;
- epsilon.auth = res[4].jwt;
+ alpha.auth = res[0].jwt ?? "";
+ beta.auth = res[1].jwt ?? "";
+ gamma.auth = res[2].jwt ?? "";
+ delta.auth = res[3].jwt ?? "";
+ epsilon.auth = res[4].jwt ?? "";
// Registration applications are now enabled by default, need to disable them
- let editSiteForm = new EditSite({
- require_application: Some(false),
- federation_debug: Some(true),
- name: None,
- sidebar: None,
- description: None,
- icon: None,
- banner: None,
- enable_downvotes: None,
- open_registration: None,
- enable_nsfw: None,
- community_creation_admin_only: None,
- require_email_verification: None,
- application_question: None,
- private_instance: None,
- default_theme: None,
- default_post_listing_type: None,
- legal_information: None,
- application_email_admins: None,
- hide_modlog_mod_names: None,
- discussion_languages: None,
- slur_filter_regex: None,
- actor_name_max_length: None,
- rate_limit_message: Some(999),
- rate_limit_message_per_second: None,
- rate_limit_post: Some(999),
- rate_limit_post_per_second: None,
- rate_limit_register: Some(999),
- rate_limit_register_per_second: None,
- rate_limit_image: Some(999),
- rate_limit_image_per_second: None,
- rate_limit_comment: Some(999),
- rate_limit_comment_per_second: None,
- rate_limit_search: Some(999),
- rate_limit_search_per_second: None,
- federation_enabled: None,
- federation_worker_count: None,
- captcha_enabled: None,
- captcha_difficulty: None,
- allowed_instances: None,
- blocked_instances: None,
+ let editSiteForm: EditSite = {
+ require_application: false,
+ federation_debug: true,
+ rate_limit_message: 999,
+ rate_limit_post: 999,
+ rate_limit_register: 999,
+ rate_limit_image: 999,
+ rate_limit_comment: 999,
+ rate_limit_search: 999,
auth: "",
- taglines: None,
- });
+ };
// Set the blocks and auths for each
- editSiteForm.auth = alpha.auth.unwrap();
- editSiteForm.allowed_instances = Some([
+ editSiteForm.auth = alpha.auth;
+ editSiteForm.allowed_instances = [
"lemmy-beta",
"lemmy-gamma",
"lemmy-delta",
"lemmy-epsilon",
- ]);
+ ];
await alpha.client.editSite(editSiteForm);
- editSiteForm.auth = beta.auth.unwrap();
- editSiteForm.allowed_instances = Some([
+ editSiteForm.auth = beta.auth;
+ editSiteForm.allowed_instances = [
"lemmy-alpha",
"lemmy-gamma",
"lemmy-delta",
"lemmy-epsilon",
- ]);
+ ];
await beta.client.editSite(editSiteForm);
- editSiteForm.auth = gamma.auth.unwrap();
- editSiteForm.allowed_instances = Some([
+ editSiteForm.auth = gamma.auth;
+ editSiteForm.allowed_instances = [
"lemmy-alpha",
"lemmy-beta",
"lemmy-delta",
"lemmy-epsilon",
- ]);
+ ];
await gamma.client.editSite(editSiteForm);
- editSiteForm.allowed_instances = Some(["lemmy-beta"]);
- editSiteForm.auth = delta.auth.unwrap();
+ editSiteForm.allowed_instances = ["lemmy-beta"];
+ editSiteForm.auth = delta.auth;
await delta.client.editSite(editSiteForm);
- editSiteForm.auth = epsilon.auth.unwrap();
- editSiteForm.allowed_instances = Some([]);
- editSiteForm.blocked_instances = Some(["lemmy-alpha"]);
+ editSiteForm.auth = epsilon.auth;
+ editSiteForm.allowed_instances = [];
+ editSiteForm.blocked_instances = ["lemmy-alpha"];
await epsilon.client.editSite(editSiteForm);
// Create the main alpha/beta communities
community_id: number
): Promise<PostResponse> {
let name = randomString(5);
- let body = Some(randomString(10));
- let url = Some("https://google.com/");
- let form = new CreatePost({
+ let body = randomString(10);
+ let url = "https://google.com/";
+ let form: CreatePost = {
name,
url,
body,
- auth: api.auth.unwrap(),
+ auth: api.auth,
community_id,
- nsfw: None,
- honeypot: None,
- language_id: None,
- });
+ };
return api.client.createPost(form);
}
export async function editPost(api: API, post: Post): Promise<PostResponse> {
- let name = Some("A jest test federated post, updated");
- let form = new EditPost({
+ let name = "A jest test federated post, updated";
+ let form: EditPost = {
name,
post_id: post.id,
- auth: api.auth.unwrap(),
- nsfw: None,
- url: None,
- body: None,
- language_id: None,
- });
+ auth: api.auth,
+ };
return api.client.editPost(form);
}
deleted: boolean,
post: Post
): Promise<PostResponse> {
- let form = new DeletePost({
+ let form: DeletePost = {
post_id: post.id,
deleted: deleted,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.deletePost(form);
}
removed: boolean,
post: Post
): Promise<PostResponse> {
- let form = new RemovePost({
+ let form: RemovePost = {
post_id: post.id,
removed,
- auth: api.auth.unwrap(),
- reason: None,
- });
+ auth: api.auth,
+ };
return api.client.removePost(form);
}
featured: boolean,
post: Post
): Promise<PostResponse> {
- let form = new FeaturePost({
+ let form: FeaturePost = {
post_id: post.id,
featured,
feature_type: PostFeatureType.Community,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.featurePost(form);
}
locked: boolean,
post: Post
): Promise<PostResponse> {
- let form = new LockPost({
+ let form: LockPost = {
post_id: post.id,
locked,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.lockPost(form);
}
api: API,
post: Post
): Promise<ResolveObjectResponse> {
- let form = new ResolveObject({
+ let form: ResolveObject = {
q: post.ap_id,
auth: api.auth,
- });
+ };
return api.client.resolveObject(form);
}
api: API,
post: Post
): Promise<SearchResponse> {
- let form = new Search({
+ let form: Search = {
q: post.name,
- type_: Some(SearchType.Posts),
- sort: Some(SortType.TopAll),
- community_id: None,
- community_name: None,
- creator_id: None,
- listing_type: None,
- page: None,
- limit: None,
- auth: api.auth,
- });
+ type_: SearchType.Posts,
+ sort: SortType.TopAll,
+ auth: api.auth,
+ };
return api.client.search(form);
}
api: API,
post_id: number
): Promise<GetPostResponse> {
- let form = new GetPost({
- id: Some(post_id),
- comment_id: None,
+ let form: GetPost = {
+ id: post_id,
auth: api.auth,
- });
+ };
return api.client.getPost(form);
}
api: API,
post_id: number
): Promise<GetCommentsResponse> {
- let form = new GetComments({
- post_id: Some(post_id),
- type_: Some(ListingType.All),
- sort: Some(CommentSortType.New), // TODO this sort might be wrong
- max_depth: None,
- page: None,
- limit: None,
- community_id: None,
- community_name: None,
- saved_only: None,
- parent_id: None,
- auth: api.auth,
- });
+ let form: GetComments = {
+ post_id: post_id,
+ type_: ListingType.All,
+ sort: CommentSortType.New,
+ auth: api.auth,
+ };
return api.client.getComments(form);
}
api: API,
comment: Comment
): Promise<ResolveObjectResponse> {
- let form = new ResolveObject({
+ let form: ResolveObject = {
q: comment.ap_id,
auth: api.auth,
- });
+ };
return api.client.resolveObject(form);
}
api: API
): Promise<ResolveObjectResponse> {
// Use short-hand search url
- let form = new ResolveObject({
+ let form: ResolveObject = {
q: "!main@lemmy-beta:8551",
auth: api.auth,
- });
+ };
return api.client.resolveObject(form);
}
api: API,
q: string
): Promise<ResolveObjectResponse> {
- let form = new ResolveObject({
+ let form: ResolveObject = {
q,
auth: api.auth,
- });
+ };
return api.client.resolveObject(form);
}
api: API,
apShortname: string
): Promise<ResolveObjectResponse> {
- let form = new ResolveObject({
+ let form: ResolveObject = {
q: apShortname,
auth: api.auth,
- });
+ };
return api.client.resolveObject(form);
}
remove_data: boolean
): Promise<BanPersonResponse> {
// Make sure lemmy-beta/c/main is cached on lemmy_alpha
- let form = new BanPerson({
+ let form: BanPerson = {
person_id,
ban,
- remove_data: Some(remove_data),
- auth: api.auth.unwrap(),
- reason: None,
- expires: None,
- });
+ remove_data: remove_data,
+ auth: api.auth,
+ };
return api.client.banPerson(form);
}
remove_data: boolean,
ban: boolean
): Promise<BanFromCommunityResponse> {
- let form = new BanFromCommunity({
+ let form: BanFromCommunity = {
person_id,
community_id,
- remove_data: Some(remove_data),
+ remove_data: remove_data,
ban,
- reason: None,
- expires: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.banFromCommunity(form);
}
follow: boolean,
community_id: number
): Promise<CommunityResponse> {
- let form = new FollowCommunity({
+ let form: FollowCommunity = {
community_id,
follow,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.followCommunity(form);
}
score: number,
post: Post
): Promise<PostResponse> {
- let form = new CreatePostLike({
+ let form: CreatePostLike = {
post_id: post.id,
score: score,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.likePost(form);
}
export async function createComment(
api: API,
post_id: number,
- parent_id: Option<number>,
+ parent_id?: number,
content = "a jest test comment"
): Promise<CommentResponse> {
- let form = new CreateComment({
+ let form: CreateComment = {
content,
post_id,
parent_id,
- form_id: None,
- language_id: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.createComment(form);
}
export async function editComment(
api: API,
comment_id: number,
- content = Some("A jest test federated comment update")
+ content = "A jest test federated comment update"
): Promise<CommentResponse> {
- let form = new EditComment({
+ let form: EditComment = {
content,
comment_id,
- form_id: None,
- language_id: None,
- distinguished: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.editComment(form);
}
deleted: boolean,
comment_id: number
): Promise<CommentResponse> {
- let form = new DeleteComment({
+ let form: DeleteComment = {
comment_id,
deleted,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.deleteComment(form);
}
removed: boolean,
comment_id: number
): Promise<CommentResponse> {
- let form = new RemoveComment({
+ let form: RemoveComment = {
comment_id,
removed,
- reason: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.removeComment(form);
}
export async function getMentions(
api: API
): Promise<GetPersonMentionsResponse> {
- let form = new GetPersonMentions({
- sort: Some(CommentSortType.New),
- unread_only: Some(false),
- auth: api.auth.unwrap(),
- page: None,
- limit: None,
- });
+ let form: GetPersonMentions = {
+ sort: CommentSortType.New,
+ unread_only: false,
+ auth: api.auth,
+ };
return api.client.getPersonMentions(form);
}
score: number,
comment: Comment
): Promise<CommentResponse> {
- let form = new CreateCommentLike({
+ let form: CreateCommentLike = {
comment_id: comment.id,
score,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.likeComment(form);
}
api: API,
name_: string = randomString(5)
): Promise<CommunityResponse> {
- let description = Some("a sample description");
- let form = new CreateCommunity({
+ let description = "a sample description";
+ let form: CreateCommunity = {
name: name_,
title: name_,
description,
- nsfw: None,
- icon: None,
- banner: None,
- posting_restricted_to_mods: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.createCommunity(form);
}
api: API,
id: number
): Promise<CommunityResponse> {
- let form = new GetCommunity({
- id: Some(id),
- name: None,
+ let form: GetCommunity = {
+ id,
auth: api.auth,
- });
+ };
return api.client.getCommunity(form);
}
deleted: boolean,
community_id: number
): Promise<CommunityResponse> {
- let form = new DeleteCommunity({
+ let form: DeleteCommunity = {
community_id,
deleted,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.deleteCommunity(form);
}
removed: boolean,
community_id: number
): Promise<CommunityResponse> {
- let form = new RemoveCommunity({
+ let form: RemoveCommunity = {
community_id,
removed,
- reason: None,
- expires: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.removeCommunity(form);
}
recipient_id: number
): Promise<PrivateMessageResponse> {
let content = "A jest test federated private message";
- let form = new CreatePrivateMessage({
+ let form: CreatePrivateMessage = {
content,
recipient_id,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.createPrivateMessage(form);
}
private_message_id: number
): Promise<PrivateMessageResponse> {
let updatedContent = "A jest test federated private message edited";
- let form = new EditPrivateMessage({
+ let form: EditPrivateMessage = {
content: updatedContent,
private_message_id,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.editPrivateMessage(form);
}
deleted: boolean,
private_message_id: number
): Promise<PrivateMessageResponse> {
- let form = new DeletePrivateMessage({
+ let form: DeletePrivateMessage = {
deleted,
private_message_id,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.deletePrivateMessage(form);
}
api: API,
username: string = randomString(5)
): Promise<LoginResponse> {
- let form = new Register({
+ let form: Register = {
username,
password,
password_verify: password,
show_nsfw: true,
- email: None,
- captcha_uuid: None,
- captcha_answer: None,
- honeypot: None,
- answer: None,
- });
+ };
return api.client.register(form);
}
export async function saveUserSettingsBio(api: API): Promise<LoginResponse> {
- let form = new SaveUserSettings({
- show_nsfw: Some(true),
- theme: Some("darkly"),
- default_sort_type: Some(Object.keys(SortType).indexOf(SortType.Active)),
- default_listing_type: Some(
- Object.keys(ListingType).indexOf(ListingType.All)
- ),
- interface_language: Some("en"),
- show_avatars: Some(true),
- send_notifications_to_email: Some(false),
- bio: Some("a changed bio"),
- avatar: None,
- banner: None,
- display_name: None,
- email: None,
- matrix_user_id: None,
- show_scores: None,
- show_read_posts: None,
- show_bot_accounts: None,
- show_new_post_notifs: None,
- bot_account: None,
- discussion_languages: None,
- auth: api.auth.unwrap(),
- });
+ let form: SaveUserSettings = {
+ show_nsfw: true,
+ theme: "darkly",
+ default_sort_type: Object.keys(SortType).indexOf(SortType.Active),
+ default_listing_type: Object.keys(ListingType).indexOf(ListingType.All),
+ interface_language: "en",
+ show_avatars: true,
+ send_notifications_to_email: false,
+ bio: "a changed bio",
+ auth: api.auth,
+ };
return saveUserSettings(api, form);
}
export async function saveUserSettingsFederated(
api: API
): Promise<LoginResponse> {
- let avatar = Some("https://image.flaticon.com/icons/png/512/35/35896.png");
- let banner = Some("https://image.flaticon.com/icons/png/512/36/35896.png");
- let bio = Some("a changed bio");
- let form = new SaveUserSettings({
- show_nsfw: Some(false),
- theme: Some(""),
- default_sort_type: Some(Object.keys(SortType).indexOf(SortType.Hot)),
- default_listing_type: Some(
- Object.keys(ListingType).indexOf(ListingType.All)
- ),
- interface_language: Some(""),
+ let avatar = "https://image.flaticon.com/icons/png/512/35/35896.png";
+ let banner = "https://image.flaticon.com/icons/png/512/36/35896.png";
+ let bio = "a changed bio";
+ let form: SaveUserSettings = {
+ show_nsfw: false,
+ default_sort_type: Object.keys(SortType).indexOf(SortType.Hot),
+ default_listing_type: Object.keys(ListingType).indexOf(ListingType.All),
+ interface_language: "",
avatar,
banner,
- display_name: Some("user321"),
- show_avatars: Some(false),
- send_notifications_to_email: Some(false),
+ display_name: "user321",
+ show_avatars: false,
+ send_notifications_to_email: false,
bio,
- email: None,
- show_scores: None,
- show_read_posts: None,
- matrix_user_id: None,
- bot_account: None,
- show_bot_accounts: None,
- show_new_post_notifs: None,
- discussion_languages: None,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return await saveUserSettings(alpha, form);
}
}
export async function deleteUser(api: API): Promise<DeleteAccountResponse> {
- let form = new DeleteAccount({
- auth: api.auth.unwrap(),
+ let form: DeleteAccount = {
+ auth: api.auth,
password,
- });
+ };
return api.client.deleteAccount(form);
}
export async function getSite(api: API): Promise<GetSiteResponse> {
- let form = new GetSite({
+ let form: GetSite = {
auth: api.auth,
- });
+ };
return api.client.getSite(form);
}
export async function listPrivateMessages(
api: API
): Promise<PrivateMessagesResponse> {
- let form = new GetPrivateMessages({
- auth: api.auth.unwrap(),
- unread_only: Some(false),
- page: None,
- limit: None,
- });
+ let form: GetPrivateMessages = {
+ auth: api.auth,
+ unread_only: false,
+ };
return api.client.getPrivateMessages(form);
}
export async function unfollowRemotes(api: API): Promise<GetSiteResponse> {
// Unfollow all remote communities
let site = await getSite(api);
- let remoteFollowed = site.my_user
- .unwrap()
- .follows.filter(c => c.community.local == false);
+ let remoteFollowed =
+ site.my_user?.follows.filter(c => c.community.local == false) ?? [];
for (let cu of remoteFollowed) {
await followCommunity(api, false, cu.community.id);
}
export async function followBeta(api: API): Promise<CommunityResponse> {
let betaCommunity = (await resolveBetaCommunity(api)).community;
- if (betaCommunity.isSome()) {
- let follow = await followCommunity(
- api,
- true,
- betaCommunity.unwrap().community.id
- );
+ if (betaCommunity) {
+ let follow = await followCommunity(api, true, betaCommunity.community.id);
return follow;
} else {
return Promise.reject("no community worked");
post_id: number,
reason: string
): Promise<PostReportResponse> {
- let form = new CreatePostReport({
+ let form: CreatePostReport = {
post_id,
reason,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.createPostReport(form);
}
export async function listPostReports(
api: API
): Promise<ListPostReportsResponse> {
- let form = new ListPostReports({
- auth: api.auth.unwrap(),
- page: None,
- limit: None,
- community_id: None,
- unresolved_only: None,
- });
+ let form: ListPostReports = {
+ auth: api.auth,
+ };
return api.client.listPostReports(form);
}
comment_id: number,
reason: string
): Promise<CommentReportResponse> {
- let form = new CreateCommentReport({
+ let form: CreateCommentReport = {
comment_id,
reason,
- auth: api.auth.unwrap(),
- });
+ auth: api.auth,
+ };
return api.client.createCommentReport(form);
}
export async function listCommentReports(
api: API
): Promise<ListCommentReportsResponse> {
- let form = new ListCommentReports({
- page: None,
- limit: None,
- community_id: None,
- unresolved_only: None,
- auth: api.auth.unwrap(),
- });
+ let form: ListCommentReports = {
+ auth: api.auth,
+ };
return api.client.listCommentReports(form);
}
await unfollowRemotes(epsilon);
}
-export function getCommentParentId(comment: Comment): Option<number> {
+export function getCommentParentId(comment: Comment): number | undefined {
let split = comment.path.split(".");
// remove the 0
split.shift();
if (split.length > 1) {
- return Some(Number(split[split.length - 2]));
+ return Number(split[split.length - 2]);
} else {
- return None;
+ return undefined;
}
}
jest.setTimeout(120000);
-import { None } from "@sniptt/monads";
import { PersonViewSafe } from "lemmy-js-client";
import {
let apShortname: string;
function assertUserFederation(
- userOne: PersonViewSafe,
- userTwo: PersonViewSafe
+ userOne?: PersonViewSafe,
+ userTwo?: PersonViewSafe
) {
- expect(userOne.person.name).toBe(userTwo.person.name);
- expect(userOne.person.display_name.unwrapOr("none")).toBe(
- userTwo.person.display_name.unwrapOr("none")
- );
- expect(userOne.person.bio.unwrapOr("none")).toBe(
- userTwo.person.bio.unwrapOr("none")
- );
- expect(userOne.person.actor_id).toBe(userTwo.person.actor_id);
- expect(userOne.person.avatar.unwrapOr("none")).toBe(
- userTwo.person.avatar.unwrapOr("none")
- );
- expect(userOne.person.banner.unwrapOr("none")).toBe(
- userTwo.person.banner.unwrapOr("none")
- );
- expect(userOne.person.published).toBe(userTwo.person.published);
+ expect(userOne?.person.name).toBe(userTwo?.person.name);
+ expect(userOne?.person.display_name).toBe(userTwo?.person.display_name);
+ expect(userOne?.person.bio).toBe(userTwo?.person.bio);
+ expect(userOne?.person.actor_id).toBe(userTwo?.person.actor_id);
+ expect(userOne?.person.avatar).toBe(userTwo?.person.avatar);
+ expect(userOne?.person.banner).toBe(userTwo?.person.banner);
+ expect(userOne?.person.published).toBe(userTwo?.person.published);
}
test("Create user", async () => {
let userRes = await registerUser(alpha);
expect(userRes.jwt).toBeDefined();
- alpha.auth = userRes.jwt;
+ alpha.auth = userRes.jwt ?? "";
let site = await getSite(alpha);
expect(site.my_user).toBeDefined();
- apShortname = `@${
- site.my_user.unwrap().local_user_view.person.name
- }@lemmy-alpha:8541`;
+ if (!site.my_user) {
+ throw "Missing site user";
+ }
+ apShortname = `@${site.my_user.local_user_view.person.name}@lemmy-alpha:8541`;
});
test("Set some user settings, check that they are federated", async () => {
await saveUserSettingsFederated(alpha);
- let alphaPerson = (await resolvePerson(alpha, apShortname)).person.unwrap();
- let betaPerson = (await resolvePerson(beta, apShortname)).person.unwrap();
+ let alphaPerson = (await resolvePerson(alpha, apShortname)).person;
+ let betaPerson = (await resolvePerson(beta, apShortname)).person;
assertUserFederation(alphaPerson, betaPerson);
});
expect(userRes.jwt).toBeDefined();
let user: API = {
client: alpha.client,
- auth: userRes.jwt,
+ auth: userRes.jwt ?? "",
};
// make a local post and comment
- let alphaCommunity = (
- await resolveCommunity(user, "!main@lemmy-alpha:8541")
- ).community.unwrap();
+ let alphaCommunity = (await resolveCommunity(user, "!main@lemmy-alpha:8541"))
+ .community;
+ if (!alphaCommunity) {
+ throw "Missing alpha community";
+ }
let localPost = (await createPost(user, alphaCommunity.community.id))
.post_view.post;
expect(localPost).toBeDefined();
- let localComment = (await createComment(user, localPost.id, None))
- .comment_view.comment;
+ let localComment = (await createComment(user, localPost.id)).comment_view
+ .comment;
expect(localComment).toBeDefined();
// make a remote post and comment
- let betaCommunity = (await resolveBetaCommunity(user)).community.unwrap();
+ let betaCommunity = (await resolveBetaCommunity(user)).community;
+ if (!betaCommunity) {
+ throw "Missing beta community";
+ }
let remotePost = (await createPost(user, betaCommunity.community.id))
.post_view.post;
expect(remotePost).toBeDefined();
- let remoteComment = (await createComment(user, remotePost.id, None))
- .comment_view.comment;
+ let remoteComment = (await createComment(user, remotePost.id)).comment_view
+ .comment;
expect(remoteComment).toBeDefined();
await deleteUser(user);
- expect((await resolvePost(alpha, localPost)).post.isNone()).toBe(true);
- expect((await resolveComment(alpha, localComment)).comment.isNone()).toBe(
- true
- );
- expect((await resolvePost(alpha, remotePost)).post.isNone()).toBe(true);
- expect((await resolveComment(alpha, remoteComment)).comment.isNone()).toBe(
- true
- );
+ expect((await resolvePost(alpha, localPost)).post).toBeUndefined();
+ expect((await resolveComment(alpha, localComment)).comment).toBeUndefined();
+ expect((await resolvePost(alpha, remotePost)).post).toBeUndefined();
+ expect((await resolveComment(alpha, remoteComment)).comment).toBeUndefined();
});
"lib": ["es2017", "es7", "es6", "dom"],
"outDir": "./dist",
"target": "ES5",
+ "strictNullChecks": true,
"moduleResolution": "Node"
},
"include": [
dependencies:
"@sinonjs/commons" "^1.7.0"
-"@sniptt/monads@^0.5.10":
- version "0.5.10"
- resolved "https://registry.yarnpkg.com/@sniptt/monads/-/monads-0.5.10.tgz#a80cd00738bbd682d36d36dd36bdc0bddc96eb76"
- integrity sha512-+agDOv9DpDV+9e2zN/Vmdk+XaqGx5Sykl0fqhqgiJ90r18nsBkxe44DmZ2sA1HYK+MSsBeZBiAr6pq4w+5uhfw==
-
"@tootallnate/once@1":
version "1.1.2"
resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-1.1.2.tgz#ccb91445360179a04e7fe6aff78c00ffc1eeaf82"
resolved "https://registry.yarnpkg.com/cjs-module-lexer/-/cjs-module-lexer-1.2.2.tgz#9f84ba3244a512f3a54e5277e8eef4c489864e40"
integrity sha512-cOU9usZw8/dXIXKtwa8pM0OTJQuJkxMN6w30csNRUerHfeQ5R6U3kkU/FtJeIf3M202OHfY2U8ccInBG7/xogA==
-class-transformer@^0.5.1:
- version "0.5.1"
- resolved "https://registry.yarnpkg.com/class-transformer/-/class-transformer-0.5.1.tgz#24147d5dffd2a6cea930a3250a677addf96ab336"
- integrity sha512-SQa1Ws6hUbfC98vKGxZH3KFY0Y1lm5Zm0SY8XX9zbK7FJCyVEac3ATW0RIpwzW+oOfmHE5PMPufDG9hCfoEOMw==
-
cliui@^7.0.2:
version "7.0.4"
resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e"
integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==
-lemmy-js-client@0.17.0-rc.56:
- version "0.17.0-rc.56"
- resolved "https://registry.yarnpkg.com/lemmy-js-client/-/lemmy-js-client-0.17.0-rc.56.tgz#2c7abba9b8195826eb36401e7c5c2cb75609bcf2"
- integrity sha512-7MM5xV8H9fIr1TbM/4e9PFKJpwlD2t135pSiH92TFgdkTzOMf0mtLO2BWLAQ7Rq+XVoVgj/WSBR4BofJka8XRQ==
+lemmy-js-client@0.17.0-rc.60:
+ version "0.17.0-rc.60"
+ resolved "https://registry.yarnpkg.com/lemmy-js-client/-/lemmy-js-client-0.17.0-rc.60.tgz#6cabac42d842eb1f152d230be018090050476614"
+ integrity sha512-Nl+DUBJde0KpKywNkX5wof9PDCmr6RuJlgukVfQRmW5rznYRKYnI1V+awf+9mUx1eNQ8jhnjVO+6XxOzMjloZA==
dependencies:
- "@sniptt/monads" "^0.5.10"
- class-transformer "^0.5.1"
node-fetch "2.6.6"
- reflect-metadata "^0.1.13"
leven@^3.1.0:
version "3.1.0"
resolved "https://registry.yarnpkg.com/react-is/-/react-is-17.0.2.tgz#e691d4a8e9c789365655539ab372762b0efb54f0"
integrity sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==
-reflect-metadata@^0.1.13:
- version "0.1.13"
- resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.1.13.tgz#67ae3ca57c972a2aa1642b10fe363fe32d49dc08"
- integrity sha512-Ts1Y/anZELhSsjMcU605fU9RE4Oi3p5ORujwbIKXfWa+0Zxs510Qrmrce5/Jowq3cHSZSJqBjypxmHarc+vEWg==
-
regexpp@^3.2.0:
version "3.2.0"
resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
projects / lemmy.git / commitdiff