@atproto/dev-env 0.3.139 → 0.3.141

package/dist/seed/thread-v2.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAG_HIDE = exports.TAG_BUMP_DOWN = void 0;
+exports.simple = simple;
+exports.long = long;
+exports.deep = deep;
+exports.branchingFactor = branchingFactor;
+exports.annotateMoreReplies = annotateMoreReplies;
+exports.annotateOP = annotateOP;
+exports.sort = sort;
+exports.bumpOpAndViewer = bumpOpAndViewer;
+exports.bumpGroupSorting = bumpGroupSorting;
+exports.bumpFollows = bumpFollows;
+exports.blockDeletionAuth = blockDeletionAuth;
+exports.mutes = mutes;
+exports.threadgated = threadgated;
+exports.tags = tags;
+function createUserStub(name) {
+    return {
+        id: name,
+        // @ts-ignore overwritten during seeding
+        did: undefined,
+        email: `${name}@test.com`,
+        handle: `${name}.test`,
+        password: `${name}-pass`,
+        displayName: name,
+        description: `hi im ${name} label_me`,
+        selfLabels: undefined,
+    };
+}
+async function createUsers(seedClient, prefix, handles) {
+    const stubs = handles.reduce((acc, handle) => {
+        acc[handle] = createUserStub(`${prefix}-${handle}`);
+        return acc;
+    }, {});
+    const users = await Promise.all(handles
+        .map((h) => prefix + '-' + h)
+        .map(async (handle) => {
+        const user = createUserStub(handle);
+        await seedClient.createAccount(handle, user);
+        user.did = seedClient.dids[handle];
+        return user;
+    }));
+    return users.reduce((acc, user) => {
+        const id = user.id.split('-')[1];
+        acc[id].did = user.did;
+        return acc;
+    }, stubs);
+}
+exports.TAG_BUMP_DOWN = 'down';
+exports.TAG_HIDE = 'hide';
+const rootReplyFnBuilder = (sc, root, parent, prevBreadcrumbs, posts) => {
+    let index = 0;
+    return async (replyAuthor, overridesOrCb, maybeReplyCb) => {
+        let overrides;
+        let replyCb;
+        if (overridesOrCb && typeof overridesOrCb === 'function') {
+            replyCb = overridesOrCb;
+        }
+        else {
+            overrides = overridesOrCb;
+            replyCb = maybeReplyCb;
+        }
+        const breadcrumbs = prevBreadcrumbs
+            ? `${prevBreadcrumbs}.${index++}`
+            : `${index++}`;
+        const text = breadcrumbs;
+        const reply = await sc.reply(replyAuthor.did, root, parent, text, undefined, undefined, overrides);
+        posts[breadcrumbs] = reply;
+        // Await for this post to be processed before replying to it.
+        replyCb && (await sc.network.processAll());
+        await replyCb?.(rootReplyFnBuilder(sc, root, reply.ref, breadcrumbs, posts));
+    };
+};
+const createThread = async (sc, rootAuthor, overridesOrCb, maybeReplyCb) => {
+    let overrides;
+    let replyCb;
+    if (overridesOrCb && typeof overridesOrCb === 'function') {
+        replyCb = overridesOrCb;
+    }
+    else {
+        overrides = overridesOrCb;
+        replyCb = maybeReplyCb;
+    }
+    const replies = {};
+    const breadcrumbs = '';
+    const text = 'root';
+    const root = await sc.post(rootAuthor.did, text, undefined, undefined, undefined, overrides);
+    // Await for this post to be processed before replying to it.
+    replyCb && (await sc.network.processAll());
+    await replyCb?.(rootReplyFnBuilder(sc, root.ref, root.ref, breadcrumbs, replies));
+    return { root, replies };
+};
+async function simple(sc, prefix = 'simple') {
+    const users = await createUsers(sc, prefix, [
+        'op',
+        'alice',
+        'bob',
+        'carol',
+    ]);
+    const { op, alice, bob, carol } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(op, async (r) => {
+            await r(op);
+        });
+        await r(alice);
+        await r(bob, async (r) => {
+            await r(alice);
+        });
+        await r(carol);
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function long(sc) {
+    const users = await createUsers(sc, 'long', [
+        'op',
+        'alice',
+        'bob',
+        'carol',
+        'dan',
+    ]);
+    const { op, alice, bob, carol, dan } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(op, async (r) => {
+            await r(op, async (r) => {
+                await r(op, async (r) => {
+                    await r(op, async (r) => {
+                        await r(op);
+                    });
+                });
+                await r(op);
+            });
+        });
+        await r(alice);
+        await r(bob);
+        await r(carol);
+        await r(op, async (r) => {
+            await r(op, async (r) => {
+                await r(alice, async (r) => {
+                    await r(op, async (r) => {
+                        await r(op);
+                    });
+                });
+            });
+        });
+        await r(alice);
+        await r(bob);
+        await r(carol);
+    });
+    await sc.like(op.did, r['5'].ref);
+    await sc.like(bob.did, r['5'].ref);
+    await sc.like(carol.did, r['5'].ref);
+    await sc.like(dan.did, r['5'].ref);
+    await sc.like(op.did, r['6'].ref);
+    await sc.like(alice.did, r['6'].ref);
+    await sc.like(carol.did, r['6'].ref);
+    await sc.like(op.did, r['7'].ref);
+    await sc.like(bob.did, r['7'].ref);
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function deep(sc) {
+    const users = await createUsers(sc, 'deep', ['op']);
+    const { op } = users;
+    let counter = 0;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        const recursiveReply = async (rFn) => {
+            if (counter < 18) {
+                counter++;
+                await rFn(op, async (r) => recursiveReply(r));
+            }
+        };
+        await recursiveReply(r);
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function branchingFactor(sc) {
+    const users = await createUsers(sc, 'bf', ['op', 'bob']);
+    const { op, bob } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(bob, async (r) => {
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+        });
+        await r(bob, async (r) => {
+            await r(bob, async (r) => {
+                // This is the only case in this seed where a reply has 1 reply instead of 4,
+                // to have cases of different lengths in the same tree.
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+        });
+        await r(bob, async (r) => {
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+        });
+        await r(bob, async (r) => {
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                // This is the only case in this seed where a reply has 5 replies instead of 4,
+                // to have cases of different lengths in the same tree.
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+            await r(bob, async (r) => {
+                await r(bob);
+                await r(bob);
+                await r(bob);
+                await r(bob);
+            });
+        });
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function annotateMoreReplies(sc) {
+    const users = await createUsers(sc, 'mr', ['op', 'alice']);
+    const { op, alice } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(alice, async (r) => {
+            await r(alice, async (r) => {
+                await r(alice, async (r) => {
+                    await r(alice, async (r) => {
+                        // more replies... (below = 4)
+                        await r(alice, async (r) => {
+                            await r(alice);
+                        });
+                        await r(alice);
+                        await r(alice, async (r) => {
+                            await r(alice, async (r) => {
+                                await r(alice);
+                            });
+                        });
+                        await r(alice);
+                        await r(alice);
+                    });
+                });
+            });
+            await r(alice, async (r) => {
+                await r(alice, async (r) => {
+                    await r(alice);
+                });
+            });
+        });
+        await r(alice, async (r) => {
+            await r(alice, async (r) => {
+                await r(alice);
+                await r(alice);
+                // more replies... (branchingFactor = 2)
+                await r(alice);
+                await r(alice);
+                await r(alice);
+            });
+            await r(alice, async (r) => {
+                await r(alice);
+                await r(alice);
+            });
+            // more replies... (branchingFactor = 2)
+            await r(alice);
+        });
+        await r(alice); // anchor reply not limited by branchingFactor
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function annotateOP(sc) {
+    const users = await createUsers(sc, 'op', ['op', 'alice', 'bob']);
+    const { op, alice, bob } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(op, async (r) => {
+            await r(op, async (r) => {
+                await r(op);
+            });
+        });
+        await r(alice, async (r) => {
+            await r(alice);
+        });
+        await r(op, async (r) => {
+            await r(bob, async (r) => {
+                await r(op);
+            });
+        });
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function sort(sc) {
+    const users = await createUsers(sc, 'sort', [
+        'op',
+        'alice',
+        'bob',
+        'carol',
+    ]);
+    const { op, alice, bob, carol } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        // 0 likes
+        await r(alice, async (r) => {
+            await r(carol); // 0 likes
+            await r(alice); // 2 likes
+            await r(bob); // 1 like
+        });
+        // 3 likes
+        await r(carol, async (r) => {
+            await r(bob); // 1 like
+            await r(carol); // 2 likes
+            await r(alice); // 0 likes
+        });
+        // 2 likes
+        await r(bob, async (r) => {
+            await r(bob); // 2 likes
+            await r(alice); // 1 like
+            await r(carol); // 0 likes
+        });
+    });
+    // likes depth 1
+    await sc.like(alice.did, r['2'].ref);
+    await sc.like(carol.did, r['2'].ref);
+    await sc.like(op.did, r['1'].ref); // op like
+    await sc.like(bob.did, r['1'].ref);
+    await sc.like(carol.did, r['1'].ref);
+    // likes depth 2
+    await sc.like(bob.did, r['0.1'].ref);
+    await sc.like(carol.did, r['0.1'].ref);
+    await sc.like(op.did, r['0.2'].ref); // op like
+    await sc.like(bob.did, r['1.1'].ref);
+    await sc.like(carol.did, r['1.1'].ref);
+    await sc.like(bob.did, r['1.0'].ref);
+    await sc.like(bob.did, r['2.0'].ref);
+    await sc.like(carol.did, r['2.0'].ref);
+    await sc.like(bob.did, r['2.1'].ref);
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function bumpOpAndViewer(sc) {
+    const users = await createUsers(sc, 'bumpOV', [
+        'op',
+        'viewer',
+        'alice',
+        'bob',
+        'carol',
+    ]);
+    const { op, viewer, alice, bob, carol } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        // 1 like
+        await r(alice, async (r) => {
+            await r(carol); // 0 likes
+            await r(alice); // 2 likes
+            await r(bob); // 1 like
+            await r(viewer); // 0 likes
+            await r(op); // 0 likes
+        });
+        // 3 likes
+        await r(carol, async (r) => {
+            await r(bob); // 1 like
+            await r(carol); // 2 likes
+            await r(op); // 0 likes
+            await r(viewer); // 1 like
+            await r(alice); // 0 likes
+        });
+        // 2 likes
+        await r(bob, async (r) => {
+            await r(viewer); // 0 likes
+            await r(bob); // 4 likes
+            await r(op); // 0 likes
+            await r(alice); // 1 like
+            await r(carol); // 1 like
+        });
+        // 0 likes
+        await r(op, async (r) => {
+            await r(viewer); // 0 likes
+            await r(bob); // 0 likes
+            await r(op); // 0 likes
+            await r(alice); // 0 likes
+            await r(carol); // 0 likes
+        });
+        // 0 likes
+        await r(viewer, async (r) => {
+            await r(bob); // 1 like
+            await r(carol); // 1 like
+            await r(op); // 0 likes
+            await r(viewer); // 0 likes
+            await r(alice); // 0 likes
+        });
+    });
+    // likes depth 1
+    await sc.like(alice.did, r['2'].ref);
+    await sc.like(carol.did, r['2'].ref);
+    await sc.like(viewer.did, r['0'].ref);
+    await sc.like(op.did, r['1'].ref); // op like
+    await sc.like(bob.did, r['1'].ref);
+    await sc.like(carol.did, r['1'].ref);
+    // likes depth 2
+    await sc.like(bob.did, r['0.1'].ref);
+    await sc.like(carol.did, r['0.1'].ref);
+    await sc.like(op.did, r['0.2'].ref); // op like
+    await sc.like(bob.did, r['1.1'].ref);
+    await sc.like(carol.did, r['1.1'].ref);
+    await sc.like(bob.did, r['1.0'].ref);
+    await sc.like(alice.did, r['2.1'].ref);
+    await sc.like(bob.did, r['2.1'].ref);
+    await sc.like(carol.did, r['2.1'].ref);
+    await sc.like(viewer.did, r['2.1'].ref);
+    await sc.like(bob.did, r['1.3'].ref);
+    await sc.like(bob.did, r['2.3'].ref);
+    await sc.like(viewer.did, r['2.4'].ref);
+    await sc.like(viewer.did, r['4.0'].ref);
+    await sc.like(alice.did, r['4.1'].ref);
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function bumpGroupSorting(sc) {
+    const users = await createUsers(sc, 'bumpGS', [
+        'op',
+        'viewer',
+        'alice',
+    ]);
+    const { op, viewer, alice } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(viewer);
+        await r(op);
+        await r(alice);
+        await r(op);
+        await r(viewer);
+        await r(op);
+        await r(alice);
+        await r(viewer);
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function bumpFollows(sc) {
+    const users = await createUsers(sc, 'bumpF', [
+        'op',
+        'viewerF',
+        'viewerNoF',
+        'alice',
+        'bob',
+        'carol',
+    ]);
+    const { op, viewerF, viewerNoF, alice, bob, carol } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(alice);
+        await r(bob);
+        await r(carol);
+        await r(op);
+        await r(viewerF);
+        await r(viewerNoF);
+    });
+    await sc.follow(viewerF.did, alice.did);
+    await sc.follow(viewerF.did, bob.did);
+    // Does not follow carol.
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function blockDeletionAuth(sc, labelerDid) {
+    const users = await createUsers(sc, 'bda', [
+        'op',
+        'opBlocked',
+        'alice',
+        'auth',
+        'blocker',
+        'blocked',
+    ]);
+    const { op, opBlocked, alice, auth, blocker, blocked } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        // 1p block, hidden for `blocked`.
+        await r(blocker, async (r) => {
+            await r(alice);
+        });
+        // 3p block, hidden for all.
+        await r(opBlocked, async (r) => {
+            await r(op);
+            await r(alice);
+        });
+        // Deleted, hidden for all.
+        await r(alice, async (r) => {
+            await r(alice);
+        });
+        // User configured to only be seend by authenticated users.
+        // Requires the test sets a `!no-unauthenticated` label for this user.
+        await r(auth, async (r) => {
+            // Another auth-only to show that the parent chain is preserved in the thread.
+            await r(auth, async (r) => {
+                await r(alice);
+            });
+        });
+    });
+    await sc.deletePost(alice.did, r['2'].ref.uri);
+    await sc.block(blocker.did, blocked.did);
+    await sc.block(op.did, opBlocked.did);
+    const db = sc.network.bsky.db.db;
+    await createLabel(db, {
+        src: labelerDid,
+        uri: auth.did,
+        cid: '',
+        val: '!no-unauthenticated',
+    });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function mutes(sc) {
+    const users = await createUsers(sc, 'mutes', [
+        'op',
+        'opMuted',
+        'alice',
+        'muted',
+        'muter',
+    ]);
+    const { op, opMuted, alice, muted, muter } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(opMuted, async (r) => {
+            await r(alice);
+            await r(muted);
+        });
+        await r(muted, async (r) => {
+            await r(opMuted);
+            await r(alice);
+        });
+    });
+    await sc.mute(op.did, opMuted.did);
+    await sc.mute(muter.did, muted.did);
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function threadgated(sc) {
+    const users = await createUsers(sc, 'tg', [
+        'op',
+        'opMuted',
+        'viewer',
+        'alice',
+        'bob',
+    ]);
+    const { op, opMuted, alice, bob } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        // Muted moves down below threadgated.
+        await r(opMuted);
+        // Threadgated moves down.
+        await r(alice, async (r) => {
+            await r(alice);
+            await r(bob);
+            await r(op); // OP moves up.
+        });
+        await r(bob, async (r) => {
+            await r(alice);
+            await r(bob); // Threadgated is omitted if fetched from the root.
+            await r(op); // OP moves down.
+        });
+    });
+    await sc.agent.app.bsky.feed.threadgate.create({
+        repo: op.did,
+        rkey: root.ref.uri.rkey,
+    }, {
+        post: root.ref.uriStr,
+        createdAt: new Date().toISOString(),
+        hiddenReplies: [r['1'].ref.uriStr, r['2.1'].ref.uriStr],
+    }, sc.getHeaders(op.did));
+    // Just throw a mute there to test the prioritization between muted and threadgated.
+    await sc.mute(op.did, opMuted.did);
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+async function tags(sc) {
+    const users = await createUsers(sc, 'tags', [
+        'op',
+        'alice',
+        'down',
+        'following',
+        'hide',
+        'viewer',
+    ]);
+    const { op, alice, down, following, hide, viewer } = users;
+    const { root, replies: r } = await createThread(sc, op, async (r) => {
+        await r(alice, async (r) => {
+            await r(alice);
+            await r(down);
+            await r(hide);
+        });
+        await r(down, async (r) => {
+            await r(alice);
+            await r(down);
+            await r(hide);
+        });
+        await r(hide, async (r) => {
+            await r(alice);
+            await r(down);
+            await r(hide);
+        });
+        await r(op);
+        await r(viewer);
+        await r(following);
+    });
+    await sc.network.processAll();
+    await sc.follow(viewer.did, following.did);
+    const db = sc.network.bsky.db.db;
+    await createTag(db, { uri: r['1'].ref.uriStr, val: exports.TAG_BUMP_DOWN });
+    await createTag(db, { uri: r['0.1'].ref.uriStr, val: exports.TAG_BUMP_DOWN });
+    await createTag(db, { uri: r['1.1'].ref.uriStr, val: exports.TAG_BUMP_DOWN });
+    await createTag(db, { uri: r['2.1'].ref.uriStr, val: exports.TAG_BUMP_DOWN });
+    await createTag(db, { uri: r['2'].ref.uriStr, val: exports.TAG_HIDE });
+    await createTag(db, { uri: r['0.2'].ref.uriStr, val: exports.TAG_HIDE });
+    await createTag(db, { uri: r['1.2'].ref.uriStr, val: exports.TAG_HIDE });
+    await createTag(db, { uri: r['2.2'].ref.uriStr, val: exports.TAG_HIDE });
+    // Neither tag affect op, viewer.
+    await createTag(db, { uri: r['3'].ref.uriStr, val: exports.TAG_BUMP_DOWN });
+    await createTag(db, { uri: r['4'].ref.uriStr, val: exports.TAG_HIDE });
+    // Tags affect following depending on the config to prioritize following.
+    await createTag(db, { uri: r['5'].ref.uriStr, val: exports.TAG_HIDE });
+    return {
+        seedClient: sc,
+        users,
+        root,
+        r,
+    };
+}
+const createLabel = async (db, opts) => {
+    await db
+        .insertInto('label')
+        .values({
+        uri: opts.uri,
+        cid: opts.cid,
+        val: opts.val,
+        cts: new Date().toISOString(),
+        exp: opts.exp ?? null,
+        neg: false,
+        src: opts.src,
+    })
+        .execute();
+};
+const createTag = async (db, opts) => {
+    await db
+        .updateTable('record')
+        .set({
+        tags: JSON.stringify([opts.val]),
+    })
+        .where('uri', '=', opts.uri)
+        .returningAll()
+        .execute();
+};
+//# sourceMappingURL=thread-v2.js.map