Something went wrong. Try again.
a tiny atproto lexicon validator
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294import { test } from "node:test";import assert from "node:assert/strict";import TinyLex from "./tinylex.js";
/** @returns {(v: unknown) => boolean} */const validator = (/** @type {any} */ def) => { const schema = new TinyLex() .add({ lexicon: 1, id: "test.x", defs: { main: def } }) .schema("test.x"); return (v) => !schema["~standard"].validate(v).issues;};
// ---------------------------------------------------------------------------// datetime format// ---------------------------------------------------------------------------
const dt = validator({ type: "string", format: "datetime" });
test("datetime: accepts valid RFC 3339", () => { assert(dt("2025-01-01T00:00:00Z")); assert(dt("2025-01-01T00:00:00.123Z")); assert(dt("2025-01-01T00:00:00.123456789Z")); assert(dt("2025-01-01T00:00:00+05:00")); assert(dt("2025-01-01T00:00:00-08:00")); assert(dt("2024-02-29T00:00:00Z"));});
test("datetime: rejects malformed strings", () => { assert(!dt("")); assert(!dt("2025-01-01")); assert(!dt("2025-01-01 00:00:00Z")); assert(!dt("2025-01-01T00:00:00")); assert(!dt("2025/01/01T00:00:00Z"));});
test("datetime: rejects out-of-range date components", () => { assert(!dt("2025-13-01T00:00:00Z")); assert(!dt("2025-00-01T00:00:00Z")); assert(!dt("2025-01-32T00:00:00Z")); assert(!dt("2025-01-00T00:00:00Z"));});
test("datetime: rejects out-of-range times", () => { assert(!dt("2025-01-01T25:00:00Z")); assert(!dt("2025-01-01T00:60:00Z")); assert(!dt("2025-01-01T00:00:60Z"));});
test("datetime: rejects -00:00 timezone", () => { assert(!dt("2025-01-01T00:00:00-00:00"));});
// ---------------------------------------------------------------------------// other formats// ---------------------------------------------------------------------------
test("handle format", () => { const v = validator({ type: "string", format: "handle" }); assert(v("alice.bsky.social")); assert(v("a.b")); assert(v("foo-bar.example.com")); assert(!v("alice")); assert(!v("-alice.bsky.social")); assert(!v("alice-.bsky.social")); assert(!v("alice..bsky.social")); assert(!v("a".repeat(254) + ".com"));});
test("did format", () => { const v = validator({ type: "string", format: "did" }); assert(v("did:plc:abc123")); assert(v("did:web:example.com")); assert(!v("plc:abc")); assert(!v("did:plc:"));});
test("at-identifier format", () => { const v = validator({ type: "string", format: "at-identifier" }); assert(v("did:plc:abc123")); assert(v("alice.bsky.social")); assert(!v("not_valid"));});
// ---------------------------------------------------------------------------// type dispatch — one happy + sad path per type// ---------------------------------------------------------------------------
test("null", () => { const v = validator({ type: "null" }); assert(v(null)); assert(!v(undefined)); assert(!v(0));});
test("boolean", () => { const v = validator({ type: "boolean" }); assert(v(true) && v(false)); assert(!v("true"));
const c = validator({ type: "boolean", const: true }); assert(c(true) && !c(false));
const e = validator({ type: "boolean", enum: [true] }); assert(e(true) && !e(false));});
test("integer", () => { const v = validator({ type: "integer" }); assert(v(0) && v(-5) && v(42)); assert(!v(1.5) && !v("1") && !v(null));
const r = validator({ type: "integer", minimum: 0, maximum: 10 }); assert(r(0) && r(10)); assert(!r(-1) && !r(11));
const c = validator({ type: "integer", const: 7 }); assert(c(7) && !c(8));
const e = validator({ type: "integer", enum: [1, 2, 3] }); assert(e(2) && !e(4));});
test("string", () => { const v = validator({ type: "string" }); assert(v("") && v("hello")); assert(!v(123));
const l = validator({ type: "string", minLength: 2, maxLength: 4 }); assert(l("ab") && l("abcd")); assert(!l("a") && !l("abcde"));
const c = validator({ type: "string", const: "x" }); assert(c("x") && !c("y"));
const e = validator({ type: "string", enum: ["a", "b"] }); assert(e("a") && !e("c"));});
test("bytes", () => { const v = validator({ type: "bytes" }); assert(v({ $bytes: "aGVsbG8=" })); assert(!v({ $bytes: "not!base64!" })); assert(!v({ $bytes: 123 })); assert(!v(null));});
test("cid-link", () => { const v = validator({ type: "cid-link" }); assert(v({ $link: "bafyabc123" })); assert(!v({ $link: "!!invalid" })); assert(!v({}));});
test("blob", () => { const v = validator({ type: "blob" }); assert(v({ $type: "blob", mimeType: "image/png", size: 100, ref: { $link: "bafy123" } })); assert(!v({ $type: "blob" })); assert(!v(null));
const accept = validator({ type: "blob", accept: ["image/*"] }); assert(accept({ $type: "blob", mimeType: "image/png", size: 1, ref: { $link: "bafy1" } })); assert(!accept({ $type: "blob", mimeType: "text/plain", size: 1, ref: { $link: "bafy1" } }));
const maxSize = validator({ type: "blob", maxSize: 100 }); assert(maxSize({ $type: "blob", mimeType: "x/y", size: 50, ref: { $link: "bafy1" } })); assert(!maxSize({ $type: "blob", mimeType: "x/y", size: 200, ref: { $link: "bafy1" } }));});
test("array", () => { const v = validator({ type: "array", items: { type: "integer" } }); assert(v([]) && v([1, 2, 3])); assert(!v([1, "two"]) && !v("not array"));
const l = validator({ type: "array", items: { type: "string" }, minLength: 1, maxLength: 2 }); assert(l(["a"]) && l(["a", "b"])); assert(!l([]) && !l(["a", "b", "c"]));});
test("object", () => { const v = validator({ type: "object", required: ["x"], properties: { x: { type: "integer" }, y: { type: "string" } }, }); assert(v({ x: 1 })); assert(v({ x: 1, y: "hi" })); assert(!v({})); assert(!v({ x: "not int" })); assert(!v(null)); assert(!v([]));
const n = validator({ type: "object", required: ["x"], nullable: ["x"], properties: { x: { type: "integer" } }, }); assert(n({ x: null }));
const nn = validator({ type: "object", properties: { x: { type: "integer" } } }); assert(!nn({ x: null }));});
test("params", () => { const v = validator({ type: "params", required: ["limit"], properties: { limit: { type: "integer" }, cursor: { type: "string" } }, }); assert(v({ limit: 10 })); assert(!v({})); assert(!v({ limit: "ten" }));});
test("unknown type", () => { const v = validator({ type: "unknown" }); assert(v({ anything: "goes" })); assert(!v(null)); assert(!v([])); assert(!v({ $link: "x" })); assert(!v({ $bytes: "x" }));});
test("record: requires $type matching the lexicon NSID", () => { const v = validator({ type: "record", record: { type: "object", required: ["x"], properties: { x: { type: "integer" } } }, }); assert(v({ $type: "test.x", x: 1 })); assert(v({ $type: "test.x#main", x: 1 })); assert(!v({ x: 1 })); assert(!v({ $type: "test.other", x: 1 })); assert(!v({ $type: "test.x" })); assert(!v(null)); assert(!v([]));});
test("token has no data representation", () => { const v = validator({ type: "token" }); assert(!v(null) && !v("anything"));});
test("unknown schema type fails gracefully", () => { const v = validator({ type: "not-a-real-type" }); assert(!v("anything"));});
// ---------------------------------------------------------------------------// ref + union (need a real catalog)// ---------------------------------------------------------------------------
test("ref resolves through catalog", () => { const catalog = new TinyLex().add({ lexicon: 1, id: "test.ref", defs: { main: { type: "object", required: ["n"], properties: { n: { type: "ref", ref: "#count" } } }, count: { type: "integer", minimum: 0 }, }, }); const schema = catalog.schema("test.ref"); assert(!schema["~standard"].validate({ n: 5 }).issues); assert(schema["~standard"].validate({ n: -1 }).issues);});
test("union: open accepts unknown $type", () => { const catalog = new TinyLex().add({ lexicon: 1, id: "test.u", defs: { main: { type: "union", refs: ["#a"] }, a: { type: "object", required: ["x"], properties: { x: { type: "integer" } } }, }, }); const schema = catalog.schema("test.u"); assert(!schema["~standard"].validate({ $type: "test.u#a", x: 1 }).issues); assert(!schema["~standard"].validate({ $type: "com.other#thing" }).issues); assert(schema["~standard"].validate({ $type: "test.u#a", x: "bad" }).issues);});
test("union: closed rejects unknown $type", () => { const catalog = new TinyLex().add({ lexicon: 1, id: "test.cu", defs: { main: { type: "union", closed: true, refs: ["#a"] }, a: { type: "object", required: ["x"], properties: { x: { type: "integer" } } }, }, }); const schema = catalog.schema("test.cu"); assert(!schema["~standard"].validate({ $type: "test.cu#a", x: 1 }).issues); assert(schema["~standard"].validate({ $type: "com.other#thing" }).issues);});