@o3co/auth.policy-verifier.builtins 0.3.1 → 0.4.0

package/dist/__tests__/module.test.mjs

@@ -1,71 +0,0 @@
-import { Registry, } from "@o3co/auth.policy-verifier.core";
-import { describe, expect, it } from "vitest";
-import { builtinCollectorsModule } from "../module.mjs";
-describe("builtinCollectorsModule", () => {
-    it("has name 'builtin-collectors'", () => {
-        expect(builtinCollectorsModule.name).toBe("builtin-collectors");
-    });
-    it("registers all builtin attribute collector factories", async () => {
-        const attributeCollectorRegistry = new Registry();
-        const ruleCollectorRegistry = new Registry();
-        const resourceParserRegistry = new Registry();
-        await builtinCollectorsModule.init({
-            pathResolver: (s) => s,
-            config: {},
-            attributeCollectorRegistry,
-            ruleCollectorRegistry,
-            resourceParserRegistry,
-        });
-        expect(attributeCollectorRegistry.has("PayloadScopeCollector")).toBe(true);
-        expect(attributeCollectorRegistry.has("PayloadSubjectIdCollector")).toBe(true);
-        expect(attributeCollectorRegistry.has("StaticPermissionCollector")).toBe(true);
-        expect(attributeCollectorRegistry.has("StaticRoleCollector")).toBe(true);
-    });
-    it("registers all builtin rule collector factories", async () => {
-        const attributeCollectorRegistry = new Registry();
-        const ruleCollectorRegistry = new Registry();
-        const resourceParserRegistry = new Registry();
-        await builtinCollectorsModule.init({
-            pathResolver: (s) => s,
-            config: {},
-            attributeCollectorRegistry,
-            ruleCollectorRegistry,
-            resourceParserRegistry,
-        });
-        expect(ruleCollectorRegistry.has("ResourceActionScopeRuleCollector")).toBe(true);
-        expect(ruleCollectorRegistry.has("ResourceActionPermissionRuleCollector")).toBe(true);
-    });
-    it("registers DotNotationResourceParser factory", async () => {
-        const attributeCollectorRegistry = new Registry();
-        const ruleCollectorRegistry = new Registry();
-        const resourceParserRegistry = new Registry();
-        await builtinCollectorsModule.init({
-            pathResolver: (s) => s,
-            config: {},
-            attributeCollectorRegistry,
-            ruleCollectorRegistry,
-            resourceParserRegistry,
-        });
-        expect(resourceParserRegistry.has("DotNotationResourceParser")).toBe(true);
-    });
-    it("creates a working StaticPermissionCollector from factory with config", async () => {
-        const attributeCollectorRegistry = new Registry();
-        const ruleCollectorRegistry = new Registry();
-        const resourceParserRegistry = new Registry();
-        await builtinCollectorsModule.init({
-            pathResolver: (s) => s,
-            config: {},
-            attributeCollectorRegistry,
-            ruleCollectorRegistry,
-            resourceParserRegistry,
-        });
-        const factory = attributeCollectorRegistry.get("StaticPermissionCollector");
-        const collector = factory({ permissions: ["admin", "read"] });
-        const attrs = await collector.collect({
-            payload: {},
-            resource: { raw: "test", resourceType: "test" },
-            action: "read",
-        });
-        expect(attrs.get("permissions")).toEqual(["admin", "read"]);
-    });
-});

package/dist/__tests__/resource/DotNotationResourceParser.test.d.mts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=DotNotationResourceParser.test.d.mts.map

package/dist/__tests__/resource/DotNotationResourceParser.test.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DotNotationResourceParser.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/resource/DotNotationResourceParser.test.mts"],"names":[],"mappings":""}

package/dist/__tests__/resource/DotNotationResourceParser.test.mjs

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DotNotationResourceParser } from "#/resource/DotNotationResourceParser.mjs";
-describe("DotNotationResourceParser", () => {
-    const parser = new DotNotationResourceParser();
-    it("parses simple type:id", () => {
-        const r = parser.parse("project:1");
-        expect(r.raw).toBe("project:1");
-        expect(r.resourceType).toBe("project");
-        expect(r.resourceId).toBe("1");
-    });
-    it("parses type-only (no id)", () => {
-        const r = parser.parse("user");
-        expect(r.raw).toBe("user");
-        expect(r.resourceType).toBe("user");
-        expect(r.resourceId).toBeUndefined();
-    });
-    it("parses nested type:id.type:id", () => {
-        const r = parser.parse("project:1.member:2");
-        expect(r.raw).toBe("project:1.member:2");
-        expect(r.resourceType).toBe("project_member");
-        expect(r.resourceId).toBe("2");
-    });
-    it("parses nested type:id.type (last has no id)", () => {
-        const r = parser.parse("project:1.member");
-        expect(r.raw).toBe("project:1.member");
-        expect(r.resourceType).toBe("project_member");
-        expect(r.resourceId).toBeUndefined();
-    });
-    it("trims whitespace", () => {
-        const r = parser.parse("  project : 1 . member : 2  ");
-        expect(r.resourceType).toBe("project_member");
-        expect(r.resourceId).toBe("2");
-    });
-});

package/dist/__tests__/rules/AttrLiteralCompare.test.d.mts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AttrLiteralCompare.test.d.mts.map

package/dist/__tests__/rules/AttrLiteralCompare.test.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttrLiteralCompare.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/rules/AttrLiteralCompare.test.mts"],"names":[],"mappings":""}

package/dist/__tests__/rules/AttrLiteralCompare.test.mjs

@@ -1,253 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { AttrLiteralCompare } from "#/rules/AttrLiteralCompare.mjs";
-describe("AttrLiteralCompare", () => {
-    // ---------------------------------------------------------------------------
-    // Happy path: each op at boundary values
-    // ---------------------------------------------------------------------------
-    it("op=lt: returns true when attr < v (5 < 10)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: 10 });
-        const attrs = new Map([["score", 5]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=lt: returns false when attr === v (10 < 10 is false)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: 10 });
-        const attrs = new Map([["score", 10]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=lt: returns false when attr > v (15 < 10 is false)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: 10 });
-        const attrs = new Map([["score", 15]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=le: returns true when attr === v (10 <= 10)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "le", v: 10 });
-        const attrs = new Map([["score", 10]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=le: returns true when attr < v (5 <= 10)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "le", v: 10 });
-        const attrs = new Map([["score", 5]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=le: returns false when attr > v (15 <= 10 is false)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "le", v: 10 });
-        const attrs = new Map([["score", 15]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=gt: returns true when attr > v (15 > 10)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        const attrs = new Map([["score", 15]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=gt: returns false when attr === v (10 > 10 is false)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        const attrs = new Map([["score", 10]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=gt: returns false when attr < v (5 > 10 is false)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        const attrs = new Map([["score", 5]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=ge: returns true when attr === v (10 >= 10)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "ge", v: 10 });
-        const attrs = new Map([["score", 10]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=ge: returns true when attr > v (15 >= 10)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "ge", v: 10 });
-        const attrs = new Map([["score", 15]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=ge: returns false when attr < v (5 >= 10 is false)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "ge", v: 10 });
-        const attrs = new Map([["score", 5]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    // ---------------------------------------------------------------------------
-    // Evaluation-time safe-deny: attr is not a number
-    // ---------------------------------------------------------------------------
-    it("returns false when attr is a string (not a number)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 5 });
-        const attrs = new Map([["score", "10"]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("returns false when attr is a boolean (not a number)", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 0 });
-        const attrs = new Map([["score", true]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    // ---------------------------------------------------------------------------
-    // Evaluation-time: NaN attribute → false for all ops
-    // ---------------------------------------------------------------------------
-    it("op=lt: returns false when attr is NaN", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: 10 });
-        const attrs = new Map([["score", NaN]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=le: returns false when attr is NaN", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "le", v: 10 });
-        const attrs = new Map([["score", NaN]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=gt: returns false when attr is NaN", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        const attrs = new Map([["score", NaN]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("op=ge: returns false when attr is NaN", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "ge", v: 10 });
-        const attrs = new Map([["score", NaN]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    // ---------------------------------------------------------------------------
-    // Evaluation-time: Infinity / -Infinity attributes
-    // ---------------------------------------------------------------------------
-    it("op=gt: Infinity > 100 returns true", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 100 });
-        const attrs = new Map([["score", Infinity]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=lt: -Infinity < 0 returns true", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: 0 });
-        const attrs = new Map([["score", -Infinity]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("op=ge: Infinity >= Infinity returns true", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "ge", v: Infinity });
-        const attrs = new Map([["score", Infinity]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    // ---------------------------------------------------------------------------
-    // Evaluation-time safe-deny: missing / null attr
-    // ---------------------------------------------------------------------------
-    it("returns false when the target attribute is missing", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 0 });
-        const attrs = new Map();
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("returns false when the target attribute is null", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 0 });
-        const attrs = new Map([["score", null]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'a'
-    // ---------------------------------------------------------------------------
-    it("throws when 'a' is undefined", () => {
-        expect(() => new AttrLiteralCompare({ a: undefined, op: "gt", v: 0 })).toThrow(/AttrLiteralCompare.*'a'.*(non-empty string|got undefined)/);
-    });
-    it("throws when 'a' is an empty string", () => {
-        expect(() => new AttrLiteralCompare({ a: "", op: "gt", v: 0 })).toThrow(/AttrLiteralCompare.*'a'.*empty string/);
-    });
-    it("throws when 'a' is a non-string (number 42)", () => {
-        expect(() => new AttrLiteralCompare({ a: 42, op: "gt", v: 0 })).toThrow(/AttrLiteralCompare.*'a'.*got number/);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'v'
-    // ---------------------------------------------------------------------------
-    it("throws when 'v' is missing (undefined)", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: undefined })).toThrow(/AttrLiteralCompare.*'v'/);
-    });
-    it("throws when 'v' is null", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: null })).toThrow(/AttrLiteralCompare.*'v'/);
-    });
-    it("throws when 'v' is a string", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: "10" })).toThrow(/AttrLiteralCompare.*'v'/);
-    });
-    it("throws when 'v' is a boolean", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: true })).toThrow(/AttrLiteralCompare.*'v'/);
-    });
-    it("throws when 'v' is a plain object", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: {} })).toThrow(/AttrLiteralCompare.*'v'/);
-    });
-    it("throws when 'v' is NaN (fail-fast at construction)", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: NaN })).toThrow(/AttrLiteralCompare.*'v'.*NaN/);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'op'
-    // ---------------------------------------------------------------------------
-    it("throws when 'op' is missing (undefined)", () => {
-        expect(() => new AttrLiteralCompare({
-            a: "score",
-            op: undefined,
-            v: 0,
-        })).toThrow(/AttrLiteralCompare.*'op'/);
-    });
-    it("throws when 'op' is not a string (number)", () => {
-        expect(() => new AttrLiteralCompare({
-            a: "score",
-            op: 42,
-            v: 0,
-        })).toThrow(/AttrLiteralCompare.*'op'/);
-    });
-    it("throws when 'op' is an invalid string ('eq')", () => {
-        expect(() => new AttrLiteralCompare({
-            a: "score",
-            op: "eq",
-            v: 0,
-        })).toThrow(/AttrLiteralCompare.*'op'/);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'group'
-    // ---------------------------------------------------------------------------
-    it("throws when 'group' is present but is an empty string", () => {
-        expect(() => new AttrLiteralCompare({ a: "score", op: "gt", v: 0, group: "" })).toThrow(/AttrLiteralCompare.*'group'.*empty string/);
-    });
-    it("throws when 'group' is present but is a non-string (number 42)", () => {
-        expect(() => new AttrLiteralCompare({
-            a: "score",
-            op: "gt",
-            v: 0,
-            group: 42,
-        })).toThrow(/AttrLiteralCompare.*'group'.*got number/);
-    });
-    // ---------------------------------------------------------------------------
-    // ruleType: default derived from a, op, v
-    // ---------------------------------------------------------------------------
-    it("derives default ruleType from a, op, and v", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        expect(rule.ruleType).toBe("attr_literal_compare:score:gt:10");
-    });
-    it("derives default ruleType for negative v", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: -5 });
-        expect(rule.ruleType).toBe("attr_literal_compare:score:lt:-5");
-    });
-    it("derives default ruleType for Infinity v", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "lt", v: Infinity });
-        expect(rule.ruleType).toBe("attr_literal_compare:score:lt:Infinity");
-    });
-    it("distinct op or v produce distinct ruleTypes (AND semantics)", () => {
-        const r1 = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        const r2 = new AttrLiteralCompare({ a: "score", op: "ge", v: 10 });
-        const r3 = new AttrLiteralCompare({ a: "score", op: "gt", v: 20 });
-        expect(r1.ruleType).not.toBe(r2.ruleType);
-        expect(r1.ruleType).not.toBe(r3.ruleType);
-    });
-    // ---------------------------------------------------------------------------
-    // ruleType: group override
-    // ---------------------------------------------------------------------------
-    it("uses the provided group string as ruleType, overriding the default", () => {
-        const r1 = new AttrLiteralCompare({ a: "score", op: "gt", v: 10, group: "score-check" });
-        const r2 = new AttrLiteralCompare({ a: "score", op: "ge", v: 11, group: "score-check" });
-        expect(r1.ruleType).toBe("score-check");
-        expect(r2.ruleType).toBe("score-check");
-    });
-    // ---------------------------------------------------------------------------
-    // code and message fields
-    // ---------------------------------------------------------------------------
-    it("has code 'attr_compare_violated'", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        expect(rule.code).toBe("attr_compare_violated");
-    });
-    it("message contains the attribute name, op, and v", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        expect(rule.message).toContain("score");
-        expect(rule.message).toContain("gt");
-        expect(rule.message).toContain("10");
-    });
-    it("message starts with a capital letter", () => {
-        const rule = new AttrLiteralCompare({ a: "score", op: "gt", v: 10 });
-        expect(rule.message[0]).toBe(rule.message[0]?.toUpperCase());
-    });
-});

package/dist/__tests__/rules/AttrLiteralEqual.test.d.mts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AttrLiteralEqual.test.d.mts.map

package/dist/__tests__/rules/AttrLiteralEqual.test.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttrLiteralEqual.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/rules/AttrLiteralEqual.test.mts"],"names":[],"mappings":""}

package/dist/__tests__/rules/AttrLiteralEqual.test.mjs

@@ -1,138 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { AttrLiteralEqual } from "#/rules/AttrLiteralEqual.mjs";
-describe("AttrLiteralEqual", () => {
-    // ---------------------------------------------------------------------------
-    // Happy path: verify() returns true
-    // ---------------------------------------------------------------------------
-    it("returns true when attr equals the configured string literal", () => {
-        const rule = new AttrLiteralEqual({ a: "role", v: "admin" });
-        const attrs = new Map([["role", "admin"]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("returns true when attr equals the configured number literal", () => {
-        const rule = new AttrLiteralEqual({ a: "age", v: 30 });
-        const attrs = new Map([["age", 30]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    it("returns true when attr equals the configured boolean literal", () => {
-        const rule = new AttrLiteralEqual({ a: "verified", v: true });
-        const attrs = new Map([["verified", true]]);
-        expect(rule.verify(attrs)).toBe(true);
-    });
-    // ---------------------------------------------------------------------------
-    // Type mismatch: no coercion
-    // ---------------------------------------------------------------------------
-    it("returns false when number literal v=30 but attr is the string '30' (no coercion)", () => {
-        const rule = new AttrLiteralEqual({ a: "age", v: 30 });
-        const attrs = new Map([["age", "30"]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("returns false when string literal v='true' but attr is the boolean true (no coercion)", () => {
-        const rule = new AttrLiteralEqual({ a: "verified", v: "true" });
-        const attrs = new Map([["verified", true]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    // ---------------------------------------------------------------------------
-    // Evaluation-time safe-deny: missing / null attr
-    // ---------------------------------------------------------------------------
-    it("returns false when the target attribute is missing", () => {
-        const rule = new AttrLiteralEqual({ a: "role", v: "admin" });
-        const attrs = new Map();
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    it("returns false when the target attribute is null", () => {
-        const rule = new AttrLiteralEqual({ a: "role", v: "admin" });
-        const attrs = new Map([["role", null]]);
-        expect(rule.verify(attrs)).toBe(false);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'a'
-    // ---------------------------------------------------------------------------
-    it("throws when 'a' is undefined", () => {
-        expect(() => new AttrLiteralEqual({ a: undefined, v: "x" })).toThrow(/AttrLiteralEqual.*'a'.*(non-empty string|got undefined)/);
-    });
-    it("throws when 'a' is an empty string", () => {
-        expect(() => new AttrLiteralEqual({ a: "", v: "x" })).toThrow(/AttrLiteralEqual.*'a'.*empty string/);
-    });
-    it("throws when 'a' is a non-string (number 42)", () => {
-        expect(() => new AttrLiteralEqual({ a: 42, v: "x" })).toThrow(/AttrLiteralEqual.*'a'.*got number/);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'v'
-    // ---------------------------------------------------------------------------
-    it("throws when 'v' is null", () => {
-        expect(() => new AttrLiteralEqual({ a: "role", v: null })).toThrow(/AttrLiteralEqual.*'v'.*got null/);
-    });
-    it("throws when 'v' is undefined", () => {
-        expect(() => new AttrLiteralEqual({ a: "role", v: undefined })).toThrow(/AttrLiteralEqual.*'v'.*got undefined/);
-    });
-    it("throws when 'v' is a plain object ({})", () => {
-        expect(() => new AttrLiteralEqual({ a: "role", v: {} })).toThrow(/AttrLiteralEqual.*'v'.*got object/);
-    });
-    it("throws when 'v' is NaN", () => {
-        // NaN === NaN is always false, so AttrLiteralEqual({ v: NaN }) would be
-        // an always-deny rule. Must fail-fast at construction rather than ship
-        // a silently-broken predicate.
-        expect(() => new AttrLiteralEqual({ a: "score", v: Number.NaN })).toThrow(/must not be NaN/);
-    });
-    // ---------------------------------------------------------------------------
-    // Construction errors: invalid 'group'
-    // ---------------------------------------------------------------------------
-    it("throws when 'group' is present but is an empty string", () => {
-        expect(() => new AttrLiteralEqual({ a: "role", v: "admin", group: "" })).toThrow(/AttrLiteralEqual.*'group'.*empty string/);
-    });
-    it("throws when 'group' is present but is a non-string (number 42)", () => {
-        expect(() => new AttrLiteralEqual({ a: "role", v: "admin", group: 42 })).toThrow(/AttrLiteralEqual.*'group'.*got number/);
-    });
-    // ---------------------------------------------------------------------------
-    // ruleType: default derived from 'a', 'typeof v', and 'String(v)'
-    // ---------------------------------------------------------------------------
-    it("derives default ruleType including the type segment for a string literal", () => {
-        const rule = new AttrLiteralEqual({ a: "role", v: "admin" });
-        expect(rule.ruleType).toBe("attr_literal_equal:role:string:admin");
-    });
-    it("derives default ruleType including the type segment for a number literal", () => {
-        const rule = new AttrLiteralEqual({ a: "age", v: 30 });
-        expect(rule.ruleType).toBe("attr_literal_equal:age:number:30");
-    });
-    it("derives default ruleType including the type segment for a boolean literal", () => {
-        const rule = new AttrLiteralEqual({ a: "verified", v: true });
-        expect(rule.ruleType).toBe("attr_literal_equal:verified:boolean:true");
-    });
-    it("distinct configs produce distinct default ruleTypes (AND semantics)", () => {
-        const r1 = new AttrLiteralEqual({ a: "role", v: "admin" });
-        const r2 = new AttrLiteralEqual({ a: "role", v: "editor" });
-        expect(r1.ruleType).not.toBe(r2.ruleType);
-    });
-    it("distinguishes literals by type in ruleType (e.g. boolean true vs string 'true')", () => {
-        // Regression guard: without the typeof-segment in ruleType, these two
-        // rules would share the same default ruleType and the evaluator would
-        // silently OR them together, weakening authorization. The type tag
-        // keeps them AND-combined as intended.
-        const r1 = new AttrLiteralEqual({ a: "status", v: true });
-        const r2 = new AttrLiteralEqual({ a: "status", v: "true" });
-        expect(r1.ruleType).not.toBe(r2.ruleType);
-    });
-    // ---------------------------------------------------------------------------
-    // ruleType: group override
-    // ---------------------------------------------------------------------------
-    it("uses the provided group string as ruleType, overriding the default", () => {
-        const r1 = new AttrLiteralEqual({ a: "role", v: "admin", group: "any-admin-role" });
-        const r2 = new AttrLiteralEqual({ a: "role", v: "superuser", group: "any-admin-role" });
-        expect(r1.ruleType).toBe("any-admin-role");
-        expect(r2.ruleType).toBe("any-admin-role");
-    });
-    // ---------------------------------------------------------------------------
-    // code and message fields
-    // ---------------------------------------------------------------------------
-    it("has code 'attr_not_equal'", () => {
-        const rule = new AttrLiteralEqual({ a: "role", v: "admin" });
-        expect(rule.code).toBe("attr_not_equal");
-    });
-    it("message contains the attribute name and literal value, and starts with a capital letter", () => {
-        const rule = new AttrLiteralEqual({ a: "role", v: "admin" });
-        expect(rule.message).toContain("role");
-        expect(rule.message).toContain("admin");
-        expect(rule.message[0]).toBe(rule.message[0]?.toUpperCase());
-    });
-});

package/dist/__tests__/rules/AttrLiteralIn.test.d.mts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AttrLiteralIn.test.d.mts.map

package/dist/__tests__/rules/AttrLiteralIn.test.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AttrLiteralIn.test.d.mts","sourceRoot":"","sources":["../../../src/__tests__/rules/AttrLiteralIn.test.mts"],"names":[],"mappings":""}