chore(ai): event schema validation tool + fixes

- Added `scripts/agent/validate-events.mjs` for builder validation.
- Enhanced `js/nostrEventSchemas.js` with `validateEventStructure`.
- Fixed `safeStringify` to handle objects correctly.
- Added `NOTE_TYPES.HTTP_AUTH` and `NOTE_TYPES.REPORT` with builders.
- Refactored `js/userBlocks.js`, `js/auth/signingAdapter.js`, `js/services/moderationService.js` to use builders.
- Updated `tests/user-blocks.test.mjs` mocks and assertions.
- Updated documentation.
This commit is contained in:
google-labs-jules[bot] committed 2026-01-24 05:36:40 +00:00
1 parent 8b1358a619
commit 6884d06192
7 files changed
+591 -270

No files matched your search

+330 -205
View File
@@ -1,23 +1,5 @@
import { strict as assert } from 'node:assert';
// Hook console.warn to capture validation warnings
const originalWarn = console.warn;
const warnings = [];
console.warn = (...args) => {
// Capture only [schema] or [nostrEventSchemas] warnings
const msg = args.join(' ');
if (msg.includes('[schema]') || msg.includes('[nostrEventSchemas]')) {
warnings.push(msg);
}
// We can still print to stdout if needed, but for validation we want to capture
// originalWarn.apply(console, args);
};
// Import schemas AFTER hooking console
const schemas = await import('../../js/nostrEventSchemas.js');
const {
validateEventAgainstSchema,
NOTE_TYPES,
import {
buildVideoPostEvent,
buildVideoMirrorEvent,
buildRepostEvent,
@@ -39,202 +21,345 @@ const {
buildSubscriptionListEvent,
buildBlockListEvent,
buildHashtagPreferenceEvent,
buildAdminListEvent
} = schemas;
buildAdminListEvent,
buildHttpAuthEvent,
buildReportEvent,
validateEventStructure,
NOTE_TYPES
} from "../../js/nostrEventSchemas.js";
console.log("Running Event Schema Validator...");
const TEST_PUBKEY = "0000000000000000000000000000000000000000000000000000000000000001";
const TEST_EVENT_ID = "1111111111111111111111111111111111111111111111111111111111111111";
const TEST_TIMESTAMP = 1700000000;
const failures = [];
const testCases = [
{
name: "Video Post",
builder: buildVideoPostEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
dTagValue: "test-video-d-tag",
content: {
version: 3,
title: "Test Video",
url: "https://example.com/video.mp4",
magnet: "magnet:?xt=urn:btih:example",
thumbnail: "https://example.com/thumb.jpg",
description: "A test video",
mode: "live",
videoRootId: "root-id-123",
deleted: false,
isPrivate: false,
isNsfw: false,
isForKids: true,
enableComments: true,
ws: "https://webseed.example.com",
xs: "http://xseed.example.com"
}
},
type: NOTE_TYPES.VIDEO_POST
},
{
name: "Video Mirror",
builder: buildVideoMirrorEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
tags: [["url", "https://example.com"], ["m", "video/mp4"]],
content: "Mirroring video..."
},
type: NOTE_TYPES.VIDEO_MIRROR
},
{
name: "Repost",
builder: buildRepostEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
eventId: TEST_EVENT_ID,
eventRelay: "wss://relay.example.com",
authorPubkey: TEST_PUBKEY,
targetEvent: { id: TEST_EVENT_ID, kind: 1, content: "test" }
},
type: NOTE_TYPES.REPOST
},
{
name: "Share",
builder: buildShareEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
content: "Check this out!",
video: { id: TEST_EVENT_ID, pubkey: TEST_PUBKEY },
relays: ["wss://relay.example.com"]
},
type: NOTE_TYPES.SHARE
},
{
name: "Relay List",
builder: buildRelayListEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
relays: [
{ url: "wss://read.example.com", mode: "read" },
{ url: "wss://write.example.com", mode: "write" }
]
},
type: NOTE_TYPES.RELAY_LIST
},
{
name: "DM Relay List",
builder: buildDmRelayListEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
relays: ["wss://dm.example.com"]
},
type: NOTE_TYPES.DM_RELAY_LIST
},
{
name: "Profile Metadata",
builder: buildProfileMetadataEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
metadata: {
name: "Alice",
about: "Hello world",
picture: "https://example.com/pic.jpg"
}
},
type: NOTE_TYPES.PROFILE_METADATA
},
{
name: "Mute List",
builder: buildMuteListEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
pTags: [TEST_PUBKEY]
},
type: NOTE_TYPES.MUTE_LIST
},
{
name: "Deletion",
builder: buildDeletionEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
eventIds: [TEST_EVENT_ID],
reason: "Mistake"
},
type: NOTE_TYPES.DELETION
},
{
name: "Legacy Direct Message",
builder: buildLegacyDirectMessageEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
recipientPubkey: TEST_PUBKEY,
ciphertext: "secretstuff"
},
type: NOTE_TYPES.LEGACY_DM
},
{
name: "DM Attachment",
builder: buildDmAttachmentEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
recipientPubkey: TEST_PUBKEY,
attachment: {
x: "hashhash",
url: "https://example.com/file",
name: "file.txt",
type: "text/plain",
size: 100
}
},
type: NOTE_TYPES.DM_ATTACHMENT
},
{
name: "DM Read Receipt",
builder: buildDmReadReceiptEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
recipientPubkey: TEST_PUBKEY,
eventId: TEST_EVENT_ID
},
type: NOTE_TYPES.DM_READ_RECEIPT
},
{
name: "DM Typing Indicator",
builder: buildDmTypingIndicatorEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
recipientPubkey: TEST_PUBKEY,
eventId: TEST_EVENT_ID,
expiresAt: TEST_TIMESTAMP + 60
},
type: NOTE_TYPES.DM_TYPING
},
{
name: "View Event",
builder: buildViewEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
pointerValue: TEST_EVENT_ID,
dedupeTag: "dedupe-123"
},
type: NOTE_TYPES.VIEW_EVENT
},
{
name: "Zap Request",
builder: buildZapRequestEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
recipientPubkey: TEST_PUBKEY,
relays: ["wss://relay.example.com"],
amountSats: 100,
lnurl: "lnurl1...",
eventId: TEST_EVENT_ID
},
type: NOTE_TYPES.ZAP_REQUEST
},
{
name: "Reaction",
builder: buildReactionEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
pointerValue: TEST_EVENT_ID,
targetPointer: { type: "e", value: TEST_EVENT_ID, relay: "wss://relay.example.com" },
content: "+"
},
type: NOTE_TYPES.VIDEO_REACTION
},
{
name: "Comment",
builder: buildCommentEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
videoEventId: TEST_EVENT_ID,
content: "Nice video!"
},
type: NOTE_TYPES.VIDEO_COMMENT
},
{
name: "Watch History",
builder: buildWatchHistoryEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
monthIdentifier: "2023-11",
content: { version: 2, month: "2023-11", items: [] }
},
type: NOTE_TYPES.WATCH_HISTORY
},
{
name: "Subscription List",
builder: buildSubscriptionListEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
content: "ciphertext",
encryption: "nip04"
},
type: NOTE_TYPES.SUBSCRIPTION_LIST
},
{
name: "Block List",
builder: buildBlockListEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
content: "ciphertext",
encryption: "nip04"
},
type: NOTE_TYPES.USER_BLOCK_LIST
},
{
name: "Hashtag Preference",
builder: buildHashtagPreferenceEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
content: "ciphertext"
},
type: NOTE_TYPES.HASHTAG_PREFERENCES
},
{
name: "Admin Moderation List",
builder: (params) => buildAdminListEvent("moderation", params),
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
hexPubkeys: [TEST_PUBKEY]
},
type: NOTE_TYPES.ADMIN_MODERATION_LIST
},
{
name: "HTTP Auth",
builder: buildHttpAuthEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
url: "https://auth.example.com",
method: "POST",
payload: "hash"
},
type: NOTE_TYPES.HTTP_AUTH
},
{
name: "Report",
builder: buildReportEvent,
params: {
pubkey: TEST_PUBKEY,
created_at: TEST_TIMESTAMP,
eventId: TEST_EVENT_ID,
userId: TEST_PUBKEY,
reportType: "spam",
relayHint: "wss://relay.example.com"
},
type: NOTE_TYPES.REPORT
}
];
function check(name, builder, params, expectedType) {
warnings.length = 0; // Clear warnings
let hasError = false;
console.log("Running Nostr Event Builder Validation...\n");
for (const testCase of testCases) {
try {
const event = builder(params);
validateEventAgainstSchema(expectedType || event.kind, event); // Pass type if known, else relies on implementation or event.kind mapping
const event = testCase.builder(testCase.params);
const { valid, errors } = validateEventStructure(testCase.type, event);
// Some builders might not set the type explicitly in validate calls if we don't instrument them yet.
// So we manually call validateEventAgainstSchema with the expected NOTE_TYPE.
if (expectedType) {
validateEventAgainstSchema(expectedType, event);
if (valid) {
console.log(`✅ ${testCase.name}`);
} else {
console.error(`❌ ${testCase.name} FAILED validation:`);
errors.forEach(err => console.error(` - ${err}`));
console.error(" Produced Event:", JSON.stringify(event, null, 2));
hasError = true;
}
if (warnings.length > 0) {
failures.push({ name, error: `Generated warnings: ${JSON.stringify(warnings)}` });
}
// specific checks can go here
if (!event.created_at) failures.push({ name, error: "Missing created_at" });
if (!event.pubkey) failures.push({ name, error: "Missing pubkey" });
} catch (e) {
failures.push({ name, error: `Threw exception: ${e.message}` });
} catch (error) {
console.error(`❌ ${testCase.name} CRASHED:`, error);
hasError = true;
}
}
const pubkey = "0000000000000000000000000000000000000000000000000000000000000001";
const created_at = Math.floor(Date.now() / 1000);
// Test cases
check("buildVideoPostEvent", buildVideoPostEvent, {
pubkey,
created_at,
dTagValue: "video-123",
content: {
version: 3,
title: "Test Video",
videoRootId: "root-123",
url: "https://example.com/video.mp4"
}
}, NOTE_TYPES.VIDEO_POST);
check("buildVideoMirrorEvent", buildVideoMirrorEvent, {
pubkey,
created_at,
tags: [["t", "test"]],
content: "Mirror description"
}, NOTE_TYPES.VIDEO_MIRROR);
check("buildRepostEvent", buildRepostEvent, {
pubkey,
created_at,
eventId: "1111111111111111111111111111111111111111111111111111111111111111",
eventRelay: "wss://relay.example.com",
serializedEvent: JSON.stringify({ id: "111", kind: 1 })
}, NOTE_TYPES.REPOST);
check("buildShareEvent", buildShareEvent, {
pubkey,
created_at,
content: "Check this out",
video: { id: "2222222222222222222222222222222222222222222222222222222222222222" }
}, NOTE_TYPES.SHARE);
check("buildRelayListEvent", buildRelayListEvent, {
pubkey,
created_at,
relays: ["wss://relay.example.com", { url: "wss://read.example.com", mode: "read" }]
}, NOTE_TYPES.RELAY_LIST);
check("buildDmRelayListEvent", buildDmRelayListEvent, {
pubkey,
created_at,
relays: ["wss://dm.example.com"]
}, NOTE_TYPES.DM_RELAY_LIST);
check("buildProfileMetadataEvent", buildProfileMetadataEvent, {
pubkey,
created_at,
metadata: { name: "Test User", about: "Testing" }
}, NOTE_TYPES.PROFILE_METADATA);
check("buildMuteListEvent", buildMuteListEvent, {
pubkey,
created_at,
pTags: ["3333333333333333333333333333333333333333333333333333333333333333"]
}, NOTE_TYPES.MUTE_LIST);
check("buildDeletionEvent", buildDeletionEvent, {
pubkey,
created_at,
eventIds: ["4444444444444444444444444444444444444444444444444444444444444444"],
reason: "Mistake"
}, NOTE_TYPES.DELETION);
check("buildLegacyDirectMessageEvent", buildLegacyDirectMessageEvent, {
pubkey,
created_at,
recipientPubkey: "5555555555555555555555555555555555555555555555555555555555555555",
ciphertext: "encryped_content"
}, NOTE_TYPES.LEGACY_DM);
check("buildDmAttachmentEvent", buildDmAttachmentEvent, {
pubkey,
created_at,
recipientPubkey: "6666666666666666666666666666666666666666666666666666666666666666",
attachment: { url: "https://example.com/file.jpg", x: "hash" }
}, NOTE_TYPES.DM_ATTACHMENT);
check("buildDmReadReceiptEvent", buildDmReadReceiptEvent, {
pubkey,
created_at,
recipientPubkey: "7777777777777777777777777777777777777777777777777777777777777777",
eventId: "8888888888888888888888888888888888888888888888888888888888888888"
}, NOTE_TYPES.DM_READ_RECEIPT);
check("buildDmTypingIndicatorEvent", buildDmTypingIndicatorEvent, {
pubkey,
created_at,
recipientPubkey: "9999999999999999999999999999999999999999999999999999999999999999"
}, NOTE_TYPES.DM_TYPING);
check("buildViewEvent", buildViewEvent, {
pubkey,
created_at,
pointerValue: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
pointerTag: ["e", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"],
dedupeTag: "session-123"
}, NOTE_TYPES.VIEW_EVENT);
check("buildZapRequestEvent", buildZapRequestEvent, {
pubkey,
created_at,
recipientPubkey: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
amountSats: 100,
relays: ["wss://zap.relay.com"]
}, NOTE_TYPES.ZAP_REQUEST);
check("buildReactionEvent", buildReactionEvent, {
pubkey,
created_at,
pointerTag: ["e", "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"],
content: "+"
}, NOTE_TYPES.VIDEO_REACTION);
check("buildCommentEvent", buildCommentEvent, {
pubkey,
created_at,
videoEventId: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
content: "Nice video!"
}, NOTE_TYPES.VIDEO_COMMENT);
check("buildWatchHistoryEvent", buildWatchHistoryEvent, {
pubkey,
created_at,
monthIdentifier: "2023-10",
content: JSON.stringify({ version: 2, month: "2023-10", items: [] })
}, NOTE_TYPES.WATCH_HISTORY);
check("buildSubscriptionListEvent", buildSubscriptionListEvent, {
pubkey,
created_at,
content: "encrypted_subs"
}, NOTE_TYPES.SUBSCRIPTION_LIST);
check("buildBlockListEvent", buildBlockListEvent, {
pubkey,
created_at,
content: "encrypted_blocks"
}, NOTE_TYPES.USER_BLOCK_LIST);
check("buildHashtagPreferenceEvent", buildHashtagPreferenceEvent, {
pubkey,
created_at,
content: "encrypted_prefs"
}, NOTE_TYPES.HASHTAG_PREFERENCES);
check("buildAdminListEvent (moderation)", (p) => buildAdminListEvent("moderation", p), {
pubkey,
created_at,
hexPubkeys: ["eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"]
}, NOTE_TYPES.ADMIN_MODERATION_LIST);
if (failures.length > 0) {
console.error("\n❌ Validation Failed:");
failures.forEach(f => {
console.error(`- ${f.name}: ${f.error}`);
});
if (hasError) {
console.log("\nValidation FAILED.");
process.exit(1);
} else {
console.log("\n✅ All events validated successfully.");
console.log("\nAll builders produced valid events.");
process.exit(0);
}