feat: implement NDKFollowPack class and related tests

pablof7z · pablof7z · commit c7df7f44357f · 2025-05-05T18:10:01.000+01:00
diff --git a/ndk-core/src/events/kinds/follow-pack.test.ts b/ndk-core/src/events/kinds/follow-pack.test.ts
@@ -0,0 +1,156 @@
+import { describe, it, expect } from "vitest";
+import { NDKFollowPack } from "./follow-pack";
+import { NDKKind } from "./index";
+import type { NDKImetaTag } from "../../utils/imeta";
+import { mapImetaTag } from "../../utils/imeta";
+
+// Helper imeta tag object
+const imetaObj: NDKImetaTag = {
+    url: "https://example.com/image.png",
+    alt: "Example image",
+    dim: "100x100"
+};
+
+describe("NDKFollowPack", () => {
+    describe("Kind Handling", () => {
+        it("should default to NDKKind.FollowPack (39089)", () => {
+            const fp = new NDKFollowPack();
+            expect(fp.kind).toBe(NDKKind.FollowPack);
+        });
+
+        it("should accept NDKKind.FollowPack and NDKKind.MediaFollowPack", () => {
+            const fp = new NDKFollowPack();
+            fp.kind = NDKKind.FollowPack;
+            expect(NDKFollowPack.kinds).toContain(fp.kind);
+
+            fp.kind = NDKKind.MediaFollowPack;
+            expect(NDKFollowPack.kinds).toContain(fp.kind);
+        });
+    });
+
+    describe("Getters/Setters", () => {
+        it("should get/set title and manipulate the title tag", () => {
+            const fp = new NDKFollowPack();
+            expect(fp.title).toBeUndefined();
+
+            fp.title = "Test Title";
+            expect(fp.title).toBe("Test Title");
+            expect(fp.tags.find(t => t[0] === "title")).toEqual(["title", "Test Title"]);
+
+            fp.title = undefined;
+            expect(fp.title).toBeUndefined();
+            expect(fp.tags.find(t => t[0] === "title")).toBeUndefined();
+        });
+
+        it("should get/set identifier (d tag)", () => {
+            const fp = new NDKFollowPack();
+            // No explicit getter/setter, use setTag/tagValue
+            expect(fp.tagValue("d")).toBeUndefined();
+
+            fp["setTag"]("d", "identifier-123");
+            expect(fp.tagValue("d")).toBe("identifier-123");
+
+            fp["setTag"]("d", undefined);
+            expect(fp.tagValue("d")).toBeUndefined();
+        });
+
+        describe("Image", () => {
+            it("should get/set image with string URL", () => {
+                const fp = new NDKFollowPack();
+                fp.image = "https://example.com/image.png";
+                expect(fp.image).toBe("https://example.com/image.png");
+                expect(fp.tags.find(t => t[0] === "image")).toEqual(["image", "https://example.com/image.png"]);
+            });
+
+            it("should get/set image with NDKImetaTag object", () => {
+                const fp = new NDKFollowPack();
+                fp.image = imetaObj;
+                // Should set both imeta and image tags
+                const imetaTag = fp.tags.find(t => t[0] === "imeta");
+                expect(imetaTag).toBeDefined();
+                expect(mapImetaTag(imetaTag! as any).url).toBe(imetaObj.url);
+                expect(fp.tags.find(t => t[0] === "image")).toEqual(["image", imetaObj.url]);
+            });
+
+            it("should prefer imeta over image when both are present", () => {
+                const fp = new NDKFollowPack();
+                fp.image = "https://fallback.com/image.png";
+                fp.image = imetaObj; // This sets both imeta and image tags
+                expect(fp.image).toBe(imetaObj.url);
+            });
+
+            it("should remove both imeta and image tags when image is set to undefined", () => {
+                const fp = new NDKFollowPack();
+                fp.image = imetaObj;
+                expect(fp.tags.find(t => t[0] === "imeta")).toBeDefined();
+                expect(fp.tags.find(t => t[0] === "image")).toBeDefined();
+
+                fp.image = undefined;
+                expect(fp.tags.find(t => t[0] === "imeta")).toBeUndefined();
+                expect(fp.tags.find(t => t[0] === "image")).toBeUndefined();
+            });
+        });
+
+        it("should get/set pubkeys and manipulate p tags", () => {
+            const fp = new NDKFollowPack();
+            expect(fp.pubkeys).toEqual([]);
+
+            fp.pubkeys = ["pk1", "pk2"];
+            expect(fp.pubkeys).toEqual(["pk1", "pk2"]);
+            expect(fp.tags.filter(t => t[0] === "p").length).toBe(2);
+
+            fp.pubkeys = [];
+            expect(fp.pubkeys).toEqual([]);
+            expect(fp.tags.find(t => t[0] === "p")).toBeUndefined();
+        });
+
+        it("should get/set description", () => {
+            const fp = new NDKFollowPack();
+            expect(fp.description).toBeUndefined();
+
+            fp.description = "A follow pack description";
+            expect(fp.description).toBe("A follow pack description");
+            expect(fp.tags.find(t => t[0] === "description")).toEqual(["description", "A follow pack description"]);
+
+            fp.description = undefined;
+            expect(fp.description).toBeUndefined();
+            expect(fp.tags.find(t => t[0] === "description")).toBeUndefined();
+        });
+    });
+
+    describe("Edge Cases", () => {
+        it("should remove tags when setting undefined values", () => {
+            const fp = new NDKFollowPack();
+            fp.title = "Test";
+            expect(fp.tags.find(t => t[0] === "title")).toBeDefined();
+
+            fp.title = undefined;
+            expect(fp.tags.find(t => t[0] === "title")).toBeUndefined();
+        });
+
+        it("should remove all p tags when setting pubkeys to empty array", () => {
+            const fp = new NDKFollowPack();
+            fp.pubkeys = ["pk1", "pk2"];
+            expect(fp.tags.filter(t => t[0] === "p").length).toBe(2);
+
+            fp.pubkeys = [];
+            expect(fp.tags.find(t => t[0] === "p")).toBeUndefined();
+        });
+
+        it("should handle malformed or missing tags gracefully", () => {
+            const fp = new NDKFollowPack();
+            // Manually add malformed tags
+            fp.tags.push(["p"]);
+            fp.tags.push(["image"]);
+            fp.tags.push(["imeta"]);
+            fp.tags.push(["title"]);
+            fp.tags.push(["description"]);
+
+            // Getters should not throw and should return undefined or empty
+            expect(fp.pubkeys).toEqual([]);
+            expect(fp.image).toBeUndefined();
+            expect(fp.title).toBeUndefined();
+            expect(fp.description).toBeUndefined();
+        });
+    });
+});
diff --git a/ndk-core/src/events/kinds/follow-pack.ts b/ndk-core/src/events/kinds/follow-pack.ts
@@ -0,0 +1,130 @@
+import type { NDK } from "../../ndk/index.js";
+import type { NostrEvent } from "../index.js";
+import { NDKEvent } from "../index.js";
+import { NDKKind } from "./index.js";
+import type { NDKImetaTag } from "../../utils/imeta.js";
+import { imetaTagToTag, mapImetaTag } from "../../utils/imeta.js";
+
+/**
+ * Represents a FollowPack or MediaFollowPack event.
+ * @group Kind Wrapper
+ */
+export class NDKFollowPack extends NDKEvent {
+    static kind = NDKKind.FollowPack;
+    static kinds = [NDKKind.FollowPack, NDKKind.MediaFollowPack];
+
+    constructor(ndk?: NDK, rawEvent?: NostrEvent) {
+        super(ndk, rawEvent);
+        this.kind ??= NDKKind.FollowPack;
+    }
+
+    /**
+     * Converts a generic NDKEvent to an NDKFollowPack.
+     */
+    static from(ndkEvent: NDKEvent): NDKFollowPack {
+        return new NDKFollowPack(ndkEvent.ndk, ndkEvent.rawEvent());
+    }
+
+    /**
+     * Gets the title from the tags.
+     */
+    get title(): string | undefined {
+        return this.tagValue("title");
+    }
+
+    /**
+     * Sets the title tag.
+     */
+    set title(value: string | undefined) {
+        this.setTag("title", value);
+    }
+
+    /**
+     * Gets the image URL from the tags.
+     */
+    /**
+     * Gets the image URL from the tags.
+     * Looks for an imeta tag first (returns its url), then falls back to the image tag.
+     */
+    get image(): string | undefined {
+        // Look for an "imeta" tag first
+        const imetaTag = this.tags.find(tag => tag[0] === "imeta");
+        if (imetaTag) {
+            const imeta = mapImetaTag(imetaTag);
+            if (imeta.url) return imeta.url;
+        }
+        // Fallback to "image" tag
+        return this.tagValue("image");
+    }
+
+    /**
+     * Sets the image URL tag.
+     */
+    /**
+     * Sets the image tag.
+     * Accepts a string (URL) or an NDKImetaTag.
+     * If given an NDKImetaTag, sets both the imeta tag and the image tag (using the url).
+     * If undefined, removes both tags.
+     */
+    set image(value: string | NDKImetaTag | undefined) {
+        // Remove existing "imeta" and "image" tags
+        this.tags = this.tags.filter(tag => tag[0] !== "imeta" && tag[0] !== "image");
+
+        if (typeof value === "string") {
+            if (value !== undefined) {
+                this.tags.push(["image", value]);
+            }
+        } else if (value && typeof value === "object") {
+            // Set imeta tag
+            this.tags.push(imetaTagToTag(value));
+            // Also set image tag if url is present
+            if (value.url) {
+                this.tags.push(["image", value.url]);
+            }
+        }
+        // If value is undefined, both tags are already removed
+    }
+
+    /**
+     * Gets all pubkeys from p tags.
+     */
+    get pubkeys(): string[] {
+        return this.tags
+            .filter(tag => tag[0] === "p" && typeof tag[1] === "string")
+            .map(tag => tag[1]);
+    }
+
+    /**
+     * Sets the pubkeys (replaces all p tags).
+     */
+    set pubkeys(pubkeys: string[]) {
+        this.tags = this.tags.filter(tag => tag[0] !== "p");
+        for (const pubkey of pubkeys) {
+            this.tags.push(["p", pubkey]);
+        }
+    }
+
+    /**
+     * Gets the description from the tags.
+     */
+    get description(): string | undefined {
+        return this.tagValue("description");
+    }
+
+    /**
+     * Sets the description tag.
+     */
+    set description(value: string | undefined) {
+        this.setTag("description", value);
+    }
+
+    /**
+     * Helper to set or update a tag.
+     */
+    protected setTag(tagName: string, value: string | undefined) {
+        this.tags = this.tags.filter(tag => tag[0] !== tagName);
+        if (value !== undefined) {
+            this.tags.push([tagName, value]);
+        }
+    }
+}
diff --git a/ndk-core/src/events/kinds/index.ts b/ndk-core/src/events/kinds/index.ts
@@ -174,6 +174,9 @@ export enum NDKKind {
     GroupAdmins = 39001, // NIP-29
     GroupMembers = 39002, // NIP-29
 
+    FollowPack = 39089,
+    MediaFollowPack = 39092,
+
     // NIP-89: App Metadata
     AppRecommendation = 31989,
     AppHandler = 31990,
diff --git a/ndk-core/src/events/wrap.ts b/ndk-core/src/events/wrap.ts
@@ -13,6 +13,7 @@ import { NDKSubscriptionTier } from "./kinds/subscriptions/tier.js";
 import { NDKVideo } from "./kinds/video.js";
 import { NDKWiki } from "./kinds/wiki.js";
 import { NDKBlossomList } from "./kinds/blossom-list.js";
+import { NDKFollowPack } from "./kinds/follow-pack.js";
 
 export function wrapEvent<T extends NDKEvent>(event: NDKEvent): T | Promise<T> | NDKEvent {
     const eventWrappingMap = new Map();
@@ -31,6 +32,7 @@ export function wrapEvent<T extends NDKEvent>(event: NDKEvent): T | Promise<T> |
         NDKList,
         NDKStory,
         NDKBlossomList,
+        NDKFollowPack,
     ]) {
         for (const kind of klass.kinds) {
             eventWrappingMap.set(kind, klass);
