@nostrify/policies 0.36.5 → 0.36.6

package/DomainPolicy.test.ts

@@ -1,11 +1,12 @@
-import { genEvent, MockRelay } from '@nostrify/nostrify/test';
-import { NostrMetadata } from '@nostrify/types';
-import { assertEquals } from '@std/assert';
-import { generateSecretKey, getPublicKey } from 'nostr-tools';
+import { test } from "node:test";
+import { genEvent, MockRelay } from "@nostrify/nostrify/test";
+import type { NostrMetadata } from "@nostrify/types";
+import { deepStrictEqual } from "node:assert";
+import { generateSecretKey, getPublicKey } from "nostr-tools";
 
-import { DomainPolicy } from './DomainPolicy.ts';
+import { DomainPolicy } from "./DomainPolicy.ts";
 
-Deno.test('DomainPolicy allows events from authors with a valid nip05', async () => {
+await test("DomainPolicy allows events from authors with a valid nip05", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -13,62 +14,73 @@ Deno.test('DomainPolicy allows events from authors with a valid nip05', async ()
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'alex@gleasonator.dev') {
+      if (nip05 === "alex@gleasonator.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
   });
 
-  const metadata: NostrMetadata = { nip05: 'alex@gleasonator.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "alex@gleasonator.dev" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, true, '']);
+  deepStrictEqual(result, ["OK", event.id, true, ""]);
 });
 
-Deno.test('DomainPolicy rejects events from authors without a kind 0', async () => {
+await test("DomainPolicy rejects events from authors without a kind 0", async () => {
   const store = new MockRelay();
   const policy = new DomainPolicy(store);
-  const event = genEvent({ kind: 1, content: 'hello world' });
+  const event = genEvent({ kind: 1, content: "hello world" });
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: author is missing a kind 0 event']);
+  deepStrictEqual(result, [
+    "OK",
+    event.id,
+    false,
+    "blocked: author is missing a kind 0 event",
+  ]);
 });
 
-Deno.test('DomainPolicy rejects events from authors with a missing nip05', async () => {
+await test("DomainPolicy rejects events from authors with a missing nip05", async () => {
   const store = new MockRelay();
   const policy = new DomainPolicy(store);
 
   const sk = generateSecretKey();
   const metadata: NostrMetadata = {};
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: missing nip05']);
+  deepStrictEqual(result, ["OK", event.id, false, "blocked: missing nip05"]);
 });
 
-Deno.test('DomainPolicy rejects events from authors with a malformed nip05', async () => {
+await test("DomainPolicy rejects events from authors with a malformed nip05", async () => {
   const store = new MockRelay();
   const policy = new DomainPolicy(store);
 
   const sk = generateSecretKey();
-  const metadata: NostrMetadata = { nip05: 'asdf' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "asdf" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: missing nip05']);
+  deepStrictEqual(result, ["OK", event.id, false, "blocked: missing nip05"]);
 });
 
-Deno.test('DomainPolicy rejects events from authors with an invalid nip05', async () => {
+await test("DomainPolicy rejects events from authors with an invalid nip05", async () => {
   const store = new MockRelay();
 
   const policy = new DomainPolicy(store, {
@@ -79,17 +91,24 @@ Deno.test('DomainPolicy rejects events from authors with an invalid nip05', asyn
     },
   });
 
-  const metadata: NostrMetadata = { nip05: 'alex@gleasonator.dev' };
+  const metadata: NostrMetadata = { nip05: "alex@gleasonator.dev" };
   const sk = generateSecretKey();
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: mismatched nip05 pubkey']);
+  deepStrictEqual(result, [
+    "OK",
+    event.id,
+    false,
+    "blocked: mismatched nip05 pubkey",
+  ]);
 });
 
-Deno.test('DomainPolicy rejects events from authors with a blacklisted nip05 domain', async () => {
+await test("DomainPolicy rejects events from authors with a blacklisted nip05 domain", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -97,25 +116,32 @@ Deno.test('DomainPolicy rejects events from authors with a blacklisted nip05 dom
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'bot@replyguy.dev') {
+      if (nip05 === "bot@replyguy.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
-    blacklist: ['replyguy.dev'],
+    blacklist: ["replyguy.dev"],
   });
 
-  const metadata: NostrMetadata = { nip05: 'bot@replyguy.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "bot@replyguy.dev" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: blacklisted nip05 domain']);
+  deepStrictEqual(result, [
+    "OK",
+    event.id,
+    false,
+    "blocked: blacklisted nip05 domain",
+  ]);
 });
 
-Deno.test("DomainPolicy rejects events from authors who aren't on a whitelisted domain", async () => {
+await test("DomainPolicy rejects events from authors who aren't on a whitelisted domain", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -123,25 +149,32 @@ Deno.test("DomainPolicy rejects events from authors who aren't on a whitelisted
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'bot@replyguy.dev') {
+      if (nip05 === "bot@replyguy.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
-    whitelist: ['gleasonator.dev'],
+    whitelist: ["gleasonator.dev"],
   });
 
-  const metadata: NostrMetadata = { nip05: 'bot@replyguy.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "bot@replyguy.dev" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: nip05 domain not in whitelist']);
+  deepStrictEqual(result, [
+    "OK",
+    event.id,
+    false,
+    "blocked: nip05 domain not in whitelist",
+  ]);
 });
 
-Deno.test('DomainPolicy allows events from authors who are on a whitelisted domain', async () => {
+await test("DomainPolicy allows events from authors who are on a whitelisted domain", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -149,25 +182,27 @@ Deno.test('DomainPolicy allows events from authors who are on a whitelisted doma
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'alex@gleasonator.dev') {
+      if (nip05 === "alex@gleasonator.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
-    whitelist: ['gleasonator.dev'],
+    whitelist: ["gleasonator.dev"],
   });
 
-  const metadata: NostrMetadata = { nip05: 'alex@gleasonator.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "alex@gleasonator.dev" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, true, '']);
+  deepStrictEqual(result, ["OK", event.id, true, ""]);
 });
 
-Deno.test('DomainPolicy rejects events from authors with a subdomain of a blacklisted domain', async () => {
+await test("DomainPolicy rejects events from authors with a subdomain of a blacklisted domain", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -175,25 +210,32 @@ Deno.test('DomainPolicy rejects events from authors with a subdomain of a blackl
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'bot@spam.replyguy.dev') {
+      if (nip05 === "bot@spam.replyguy.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
-    blacklist: ['replyguy.dev'],
+    blacklist: ["replyguy.dev"],
   });
 
-  const metadata: NostrMetadata = { nip05: 'bot@spam.replyguy.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "bot@spam.replyguy.dev" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: blacklisted nip05 domain']);
+  deepStrictEqual(result, [
+    "OK",
+    event.id,
+    false,
+    "blocked: blacklisted nip05 domain",
+  ]);
 });
 
-Deno.test('DomainPolicy rejects events from authors with a deeply nested subdomain of a blacklisted domain', async () => {
+await test("DomainPolicy rejects events from authors with a deeply nested subdomain of a blacklisted domain", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -201,25 +243,34 @@ Deno.test('DomainPolicy rejects events from authors with a deeply nested subdoma
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'user@deep.nested.spam.replyguy.dev') {
+      if (nip05 === "user@deep.nested.spam.replyguy.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
-    blacklist: ['replyguy.dev'],
+    blacklist: ["replyguy.dev"],
   });
 
-  const metadata: NostrMetadata = { nip05: 'user@deep.nested.spam.replyguy.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = {
+    nip05: "user@deep.nested.spam.replyguy.dev",
+  };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, false, 'blocked: blacklisted nip05 domain']);
+  deepStrictEqual(result, [
+    "OK",
+    event.id,
+    false,
+    "blocked: blacklisted nip05 domain",
+  ]);
 });
 
-Deno.test('DomainPolicy allows events from authors with similar but not subdomain of blacklisted domain', async () => {
+await test("DomainPolicy allows events from authors with similar but not subdomain of blacklisted domain", async () => {
   const sk = generateSecretKey();
   const pubkey = getPublicKey(sk);
 
@@ -227,20 +278,22 @@ Deno.test('DomainPolicy allows events from authors with similar but not subdomai
   const policy = new DomainPolicy(store, {
     // deno-lint-ignore require-await
     async lookup(nip05: string) {
-      if (nip05 === 'user@notreplyguy.dev') {
+      if (nip05 === "user@notreplyguy.dev") {
         return { pubkey };
       } else {
-        throw new Error('not found');
+        throw new Error("not found");
       }
     },
-    blacklist: ['replyguy.dev'],
+    blacklist: ["replyguy.dev"],
   });
 
-  const metadata: NostrMetadata = { nip05: 'user@notreplyguy.dev' };
-  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
-  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+  const metadata: NostrMetadata = { nip05: "user@notreplyguy.dev" };
+  await store.event(
+    genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk),
+  );
+  const event = genEvent({ kind: 1, content: "hello world" }, sk);
 
   const result = await policy.call(event);
 
-  assertEquals(result, ['OK', event.id, true, '']);
+  deepStrictEqual(result, ["OK", event.id, true, ""]);
 });

package/DomainPolicy.ts

@@ -1,7 +1,7 @@
 import { NIP05, NSchema as n } from '@nostrify/nostrify';
-import { NPolicy, NProfilePointer, NStore } from '@nostrify/types';
+import type { NostrEvent, NPolicy, NProfilePointer, NStore } from '@nostrify/types';
 
-import { AuthorPolicy } from './AuthorPolicy.js';
+import { AuthorPolicy } from './AuthorPolicy.ts';
 
 /** Options for `DomainPolicy`. */
 interface DomainPolicyOpts {
@@ -17,7 +17,7 @@ interface DomainPolicyOpts {
 export class DomainPolicy extends AuthorPolicy implements NPolicy {
   constructor(store: NStore, opts: DomainPolicyOpts = {}) {
     super(store, {
-      async call(event, signal) {
+      async call(event: NostrEvent, signal: AbortSignal) {
         const { blacklist = [], whitelist, lookup = DomainPolicy.lookup } = opts;
 
         const metadata = n.json().pipe(n.metadata()).safeParse(event.content);

package/FiltersPolicy.test.ts

@@ -1,14 +1,21 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { FiltersPolicy } from './FiltersPolicy.ts';
+import { FiltersPolicy } from "./FiltersPolicy.ts";
 
-Deno.test('FiltersPolicy', async () => {
+await test("FiltersPolicy", async () => {
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
-  assertEquals((await new FiltersPolicy([{ kinds: [1] }]).call(event))[2], true);
-  assertEquals((await new FiltersPolicy([{ kinds: [1], authors: [] }]).call(event))[2], false);
+  deepStrictEqual(
+    (await new FiltersPolicy([{ kinds: [1] }]).call(event))[2],
+    true,
+  );
+  deepStrictEqual(
+    (await new FiltersPolicy([{ kinds: [1], authors: [] }]).call(event))[2],
+    false,
+  );
 });

package/FiltersPolicy.ts

@@ -1,6 +1,6 @@
 import { matchFilters } from 'nostr-tools';
 
-import { NostrEvent, NostrFilter, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrFilter, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * Reject events which don't match the filters.
@@ -14,7 +14,10 @@ import { NostrEvent, NostrFilter, NostrRelayOK, NPolicy } from '@nostrify/types'
  * ```
  */
 export class FiltersPolicy implements NPolicy {
-  constructor(private filters: NostrFilter[]) {}
+  private filters: NostrFilter[];
+  constructor(filters: NostrFilter[]) {
+    this.filters = filters;
+  }
 
   // deno-lint-ignore require-await
   async call(event: NostrEvent): Promise<NostrRelayOK> {

package/HashtagPolicy.test.ts

@@ -1,34 +1,45 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { HashtagPolicy } from './HashtagPolicy.ts';
+import { HashtagPolicy } from "./HashtagPolicy.ts";
 
-Deno.test('HashtagPolicy', async () => {
-  const hashtags = ['nsfw'];
+await test("HashtagPolicy", async () => {
+  const hashtags = ["nsfw"];
 
   const event1 = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const event2 = finalizeEvent(
-    { kind: 1, content: '', tags: [['t', 'nsfw'], ['t', 'other']], created_at: 0 },
+    {
+      kind: 1,
+      content: "",
+      tags: [["t", "nsfw"], ["t", "other"]],
+      created_at: 0,
+    },
     generateSecretKey(),
   );
 
   const event3 = finalizeEvent(
-    { kind: 1, content: 'nsfw', tags: [], created_at: 0 },
+    { kind: 1, content: "nsfw", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const event4 = finalizeEvent(
-    { kind: 1, content: '', tags: [['p', 'nsfw'], ['t', 'other']], created_at: 0 },
+    {
+      kind: 1,
+      content: "",
+      tags: [["p", "nsfw"], ["t", "other"]],
+      created_at: 0,
+    },
     generateSecretKey(),
   );
 
-  assertEquals((await new HashtagPolicy(hashtags).call(event1))[2], true);
-  assertEquals((await new HashtagPolicy(hashtags).call(event2))[2], false);
-  assertEquals((await new HashtagPolicy([]).call(event2))[2], true);
-  assertEquals((await new HashtagPolicy(hashtags).call(event3))[2], true);
-  assertEquals((await new HashtagPolicy(hashtags).call(event4))[2], true);
+  deepStrictEqual((await new HashtagPolicy(hashtags).call(event1))[2], true);
+  deepStrictEqual((await new HashtagPolicy(hashtags).call(event2))[2], false);
+  deepStrictEqual((await new HashtagPolicy([]).call(event2))[2], true);
+  deepStrictEqual((await new HashtagPolicy(hashtags).call(event3))[2], true);
+  deepStrictEqual((await new HashtagPolicy(hashtags).call(event4))[2], true);
 });

package/HashtagPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * Reject events containing any of the banned hashtags.
@@ -10,7 +10,10 @@ import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
  * ```
  */
 export class HashtagPolicy implements NPolicy {
-  constructor(private hashtags: string[]) {}
+  private hashtags: string[];
+  constructor(hashtags: string[]) {
+    this.hashtags = hashtags;
+  }
 
   // deno-lint-ignore require-await
   async call({ id, tags }: NostrEvent): Promise<NostrRelayOK> {

package/HellthreadPolicy.test.ts

@@ -1,23 +1,24 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { HellthreadPolicy } from './HellthreadPolicy.ts';
+import { HellthreadPolicy } from "./HellthreadPolicy.ts";
 
-Deno.test('HellthreadPolicy', async () => {
+await test("HellthreadPolicy", async () => {
   const policy = new HellthreadPolicy({ limit: 1 });
 
   const okEvent = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const badEvent = finalizeEvent({
     kind: 1,
-    content: '',
-    tags: [['p'], ['p'], ['p']],
+    content: "",
+    tags: [["p"], ["p"], ["p"]],
     created_at: 0,
   }, generateSecretKey());
 
-  assertEquals((await policy.call(okEvent))[2], true);
-  assertEquals((await policy.call(badEvent))[2], false);
+  deepStrictEqual((await policy.call(okEvent))[2], true);
+  deepStrictEqual((await policy.call(badEvent))[2], false);
 });

package/HellthreadPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /** Policy options for `HellthreadPolicy`. */
 interface HellthreadPolicyOpts {
@@ -8,14 +8,17 @@ interface HellthreadPolicyOpts {
 
 /** Basic policy to demonstrate how policies work. Accepts all events. */
 export class HellthreadPolicy implements NPolicy {
-  constructor(private opts: HellthreadPolicyOpts = {}) {}
+  private opts: HellthreadPolicyOpts;
+  constructor(opts: HellthreadPolicyOpts = {}) {
+    this.opts = opts;
+  }
 
   // deno-lint-ignore require-await
   async call({ id, kind, tags }: NostrEvent): Promise<NostrRelayOK> {
     const { limit = 100 } = this.opts;
 
     if (kind === 1) {
-      const p = tags.filter((tag) => tag[0] === 'p');
+      const p = tags.filter((tag: string[]) => tag[0] === 'p');
 
       if (p.length > limit) {
         return ['OK', id, false, `blocked: rejected due to ${p.length} "p" tags (${limit} is the limit).`];

package/InvertPolicy.test.ts

@@ -1,19 +1,20 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { InvertPolicy } from './InvertPolicy.ts';
-import { NoOpPolicy } from './NoOpPolicy.ts';
+import { InvertPolicy } from "./InvertPolicy.ts";
+import { NoOpPolicy } from "./NoOpPolicy.ts";
 
-Deno.test('InvertPolicy', async () => {
-  const policy = new InvertPolicy(new NoOpPolicy(), 'blocked: inverted');
+await test("InvertPolicy", async () => {
+  const policy = new InvertPolicy(new NoOpPolicy(), "blocked: inverted");
 
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const [_, _eventId, ok, reason] = await policy.call(event);
 
-  assertEquals(ok, false);
-  assertEquals(reason, 'blocked: inverted');
+  deepStrictEqual(ok, false);
+  deepStrictEqual(reason, "blocked: inverted");
 });

package/InvertPolicy.ts

@@ -1,8 +1,14 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /** Rejects if the policy passes, passes if the policy rejects. */
 export class InvertPolicy implements NPolicy {
-  constructor(private policy: NPolicy, private reason: string) {}
+  private policy: NPolicy;
+  private reason: string;
+
+  constructor(policy: NPolicy, reason: string) {
+    this.policy = policy;
+    this.reason = reason;
+  }
 
   async call(event: NostrEvent): Promise<NostrRelayOK> {
     const result = await this.policy.call(event);