jinaga-server 3.6.0 → 3.7.0

package/test/authorization/intermediateProjectionFeedSpec.ts

@@ -0,0 +1,189 @@
+import {
+    AuthorizationRules,
+    buildModel,
+    dehydrateFact,
+    DistributionRules,
+    FactManager,
+    Forbidden,
+    MemoryStore,
+    NetworkNoOp,
+    ObservableSource,
+    PassThroughFork,
+    User
+} from "jinaga";
+
+import { AuthorizationKeystore } from "../../src/authorization/authorization-keystore";
+import { MemoryKeystore } from "../../src/memory/memory-keystore";
+
+// Integration coverage for jinaga issue #204: a distribution rule whose
+// `.select()` projection traverses *through* an intermediate fact (here
+// `Finalist`, used only to reach the `competitor` it projects) must authorize an
+// authorized user's direct query for that intermediate fact. The same
+// DistributionEngine that JinagaTest uses also backs this server-side
+// authorization path (`AuthorizationKeystore.read` -> `canDistributeToAll`,
+// constructed with isTest=false), so the behavior must match.
+//
+// The sub-feed authorization relaxation this exercises landed in jinaga 6.8.2.
+
+class Tenant {
+    public static Type = "Tenant" as const;
+    public type = Tenant.Type;
+    constructor(public creator: User) { }
+}
+
+class Administrator {
+    public static Type = "Administrator" as const;
+    public type = Administrator.Type;
+    constructor(public tenant: Tenant, public user: User, public createdAt: Date | string) { }
+}
+
+class Event {
+    public static Type = "Event" as const;
+    public type = Event.Type;
+    constructor(public tenant: Tenant, public id: string) { }
+}
+
+class Competitor {
+    public static Type = "Competitor" as const;
+    public type = Competitor.Type;
+    constructor(public tenant: Tenant) { }
+}
+
+// Finalist is the intermediate: the projection joins Event -> Finalist only to
+// reach the Competitor predecessor; Finalist is never a named component.
+class Finalist {
+    public static Type = "Finalist" as const;
+    public type = Finalist.Type;
+    constructor(public competitor: Competitor, public event: Event) { }
+}
+
+class CompetitorName {
+    public static Type = "CompetitorName" as const;
+    public type = CompetitorName.Type;
+    constructor(public competitor: Competitor, public value: string, public prior: CompetitorName[]) { }
+}
+
+const model = buildModel(b => b
+    .type(User)
+    .type(Tenant, m => m.predecessor("creator", User))
+    .type(Administrator, m => m
+        .predecessor("tenant", Tenant)
+        .predecessor("user", User))
+    .type(Event, m => m.predecessor("tenant", Tenant))
+    .type(Competitor, m => m.predecessor("tenant", Tenant))
+    .type(Finalist, m => m
+        .predecessor("competitor", Competitor)
+        .predecessor("event", Event))
+    .type(CompetitorName, m => m
+        .predecessor("competitor", Competitor)
+        .predecessor("prior", CompetitorName))
+);
+
+const finalistsOfEvent = model.given(Event).match((event, facts) =>
+    facts.ofType(Finalist).join(finalist => finalist.event, event)
+).specification;
+
+const subscriberIdentity = { provider: "mock", id: "subscriber" };
+const creatorIdentity = { provider: "mock", id: "creator" };
+
+describe("AuthorizationKeystore.read with intermediate projection facts (jinaga #204)", () => {
+    it("authorizes an administrator's direct query for an intermediate projection fact", async () => {
+        const setup = await givenAuthorization(/* subscriberIsAdmin */ true);
+
+        const eventRef = dehydrateFact(setup.event).find(f => f.type === Event.Type)!;
+
+        // Should resolve (not throw Forbidden) and return the seeded finalist.
+        const results = await setup.authorization.read(
+            subscriberIdentity, [eventRef], finalistsOfEvent);
+
+        expect(results).toHaveLength(1);
+    });
+
+    it("still denies a non-administrator's direct query for the same fact", async () => {
+        const setup = await givenAuthorization(/* subscriberIsAdmin */ false);
+
+        const eventRef = dehydrateFact(setup.event).find(f => f.type === Event.Type)!;
+
+        // Assert the specific authorization denial, not just any error, so a
+        // setup/engine failure can't masquerade as a passing regression guard.
+        const read = setup.authorization.read(subscriberIdentity, [eventRef], finalistsOfEvent);
+        await expect(read).rejects.toThrow(Forbidden);
+        await expect(read).rejects.toThrow(/Cannot distribute/);
+    });
+});
+
+async function givenAuthorization(subscriberIsAdmin: boolean) {
+    const storage = new MemoryStore();
+    const keystore = new MemoryKeystore();
+
+    const subscriberFact = await keystore.getOrCreateUserFact(subscriberIdentity);
+    const creatorFact = await keystore.getOrCreateUserFact(creatorIdentity);
+    const subscriber = new User(subscriberFact.fields.publicKey);
+    const creator = new User(creatorFact.fields.publicKey);
+
+    const tenant = new Tenant(creator);
+    const event = new Event(tenant, "event-id");
+    const competitor = new Competitor(tenant);
+    const finalist = new Finalist(competitor, event);
+
+    const facts = [
+        ...dehydrateFact(subscriber),
+        ...dehydrateFact(creator),
+        ...dehydrateFact(event),
+        ...dehydrateFact(competitor),
+        ...dehydrateFact(finalist)
+    ];
+    if (subscriberIsAdmin) {
+        const administrator = new Administrator(tenant, subscriber, new Date("2024-01-01"));
+        facts.push(...dehydrateFact(administrator));
+    }
+
+    // Dedupe by hash+type to avoid double-saving shared predecessors.
+    const seenKeys = new Set<string>();
+    const uniqueFacts = facts.filter(f => {
+        const k = `${f.type}|${f.hash}`;
+        if (seenKeys.has(k)) return false;
+        seenKeys.add(k);
+        return true;
+    });
+    await storage.save(uniqueFacts.map(f => ({ fact: f, signatures: [] })));
+
+    const fork = new PassThroughFork(storage);
+    const observable = new ObservableSource(storage);
+    const network = new NetworkNoOp();
+    const factManager = new FactManager(fork, observable, storage, network, []);
+
+    const authorizationRules = new AuthorizationRules(model)
+        .no(User)
+        .any(Tenant)
+        .any(Administrator)
+        .any(Event)
+        .any(Competitor)
+        .any(Finalist)
+        .any(CompetitorName);
+
+    const distributionRules = new DistributionRules([])
+        .share(model.given(Event).select((event, facts) => ({
+            // Finalist is only a traversal step toward the competitor projection.
+            finalists: facts.ofType(Finalist)
+                .join(finalist => finalist.event, event)
+                .selectMany(finalist => finalist.competitor.predecessor()
+                    .select(competitor => ({
+                        competitorNames: facts.ofType(CompetitorName)
+                            .join(name => name.competitor, competitor)
+                            .notExists(name => facts.ofType(CompetitorName)
+                                .join(next => next.prior, name)
+                            )
+                    }))
+                )
+        })))
+        .with(model.given(Event).match((event, facts) =>
+            facts.ofType(Administrator)
+                .join(a => a.tenant, event.tenant)
+                .selectMany(a => facts.ofType(User).join(u => u, a.user))
+        ));
+
+    const authorization = new AuthorizationKeystore(
+        factManager, storage, keystore, authorizationRules, distributionRules);
+    return { authorization, event };
+}

package/test/authorization/subscriptionIntersectionSpec.ts

@@ -68,6 +68,8 @@ describe("AuthorizationKeystore.verifyDistributionOrIntersect", () => {
         expect(result.branches).toHaveLength(1);
         expect(result.branches[0].specification).toBe(officeSpec);
         expect(result.branches[0].start).toEqual([companyRef]);
+        // Pass-through authorized: no engine denial is carried.
+        expect(result.denial).toBeUndefined();
     });
 
     it("returns intersected branches when the user is not yet authorized", async () => {
@@ -100,6 +102,12 @@ describe("AuthorizationKeystore.verifyDistributionOrIntersect", () => {
             type: setup.subscriberFact.type,
             hash: setup.subscriberFact.hash
         });
+        // Authorized-via-intersection (reactive) carries the engine failure
+        // that triggered it: the authenticated subscriber is excluded until
+        // the authorizing Administrator fact arrives.
+        expect(result.denial).toBeDefined();
+        expect(result.denial?.code).toBe("principal-excluded");
+        expect(result.denial?.reason).toBeTruthy();
     });
 
     it("returns denied when no distribution rule applies to the spec", async () => {
@@ -122,6 +130,8 @@ describe("AuthorizationKeystore.verifyDistributionOrIntersect", () => {
         expect(result.type).toBe("denied");
         if (result.type !== "denied") return;
         expect(result.reason).toBeTruthy();
+        // No rule covers this spec at all.
+        expect(result.code).toBe("no-matching-rule");
     });
 
     it("returns a passthrough branch when there are no distribution rules at all", async () => {
@@ -144,6 +154,8 @@ describe("AuthorizationKeystore.verifyDistributionOrIntersect", () => {
         if (result.type !== "success") return;
         expect(result.branches).toHaveLength(1);
         expect(result.branches[0].specification).toBe(officeSpec);
+        // No distribution engine, so nothing is denied — pure pass-through.
+        expect(result.denial).toBeUndefined();
     });
 });
 

package/test/feeds/feedStreamSessionRegressionSpec.ts

@@ -0,0 +1,227 @@
+import {
+    buildFeeds,
+    computeObjectHash,
+    FactFeed,
+    FactManager,
+    FactReference,
+    FeedObject,
+    FeedResponse,
+    ProjectedResult,
+    ReferencesByName,
+    Specification,
+    SpecificationListener,
+    SpecificationParser
+} from "jinaga";
+
+import { FeedResult } from "../../src/authorization/authorization-keystore";
+import { FeedStreamSession } from "../../src/feeds/feed-stream-session";
+import { Stream } from "../../src/http/stream";
+
+// Regression coverage for scenarios the primary unit spec does not exercise:
+// a store whose bookmark actually advances across a real-time update, recovery
+// of a fact that was dropped from the waitlist as "stale", and disposal while
+// a query is in flight. These lock down the core streaming guarantees against
+// future changes to the cycle/waitlist logic.
+
+function buildFeedDefinition(): { feedDefinition: FeedObject; givenHash: string } {
+    const anchorHash = "anchorhash000000000000000000000000000000000000";
+    const input =
+        `let p: Jinaga.User = #${anchorHash}\n` +
+        `(p: Jinaga.User) {\n` +
+        `    post: Test.Post [\n` +
+        `        post->author: Jinaga.User = p\n` +
+        `    ]\n` +
+        `} => post`;
+    const parser = new SpecificationParser(input);
+    parser.skipWhitespace();
+    const declaration = parser.parseDeclaration([]);
+    const specification = parser.parseSpecification();
+    const start = specification.given.map(g => {
+        const declared = declaration.find(d => d.name === g.label.name);
+        return declared!.declared.reference;
+    });
+    const namedStart = specification.given.reduce((map, g, index) => ({
+        ...map,
+        [g.label.name]: start[index]
+    }), {} as ReferencesByName);
+    const feed = buildFeeds(specification)[0];
+    const feedDefinition: FeedObject = { feed, namedStart };
+    const givenHash = computeObjectHash(namedStart);
+    return { feedDefinition, givenHash };
+}
+
+class FakeFactManager {
+    public listeners: { specification: Specification; onResult: (results: ProjectedResult[]) => Promise<void> }[] = [];
+    public removed: SpecificationListener[] = [];
+    addSpecificationListener(
+        specification: Specification,
+        onResult: (results: ProjectedResult[]) => Promise<void>
+    ): SpecificationListener {
+        const listener = { specification, onResult } as unknown as SpecificationListener;
+        this.listeners.push({ specification, onResult });
+        return listener;
+    }
+    removeSpecificationListener(listener: SpecificationListener): void {
+        this.removed.push(listener);
+    }
+}
+
+function ref(type: string, hash: string): FactReference {
+    return { type, hash };
+}
+function tuple(...facts: FactReference[]): { facts: FactReference[]; bookmark: string } {
+    return { facts, bookmark: "" };
+}
+function page(bookmark: string, tuples: { facts: FactReference[]; bookmark: string }[]): FeedResult {
+    return { type: "success", feed: { tuples, bookmark } as FactFeed };
+}
+function emptyPage(bookmark: string): FeedResult {
+    return page(bookmark, []);
+}
+
+function makeSession(
+    query: (bookmark: string) => Promise<FeedResult>,
+    options: {
+        initialBookmark?: string;
+        config?: ConstructorParameters<typeof FeedStreamSession>[8];
+        stream?: Stream<FeedResponse>;
+        factManager?: FakeFactManager;
+    } = {}
+): { session: FeedStreamSession; stream: Stream<FeedResponse>; received: FeedResponse[]; factManager: FakeFactManager } {
+    const { feedDefinition, givenHash } = buildFeedDefinition();
+    const start = feedDefinition.feed.given.map(g => feedDefinition.namedStart[g.label.name]);
+    const stream = options.stream ?? new Stream<FeedResponse>();
+    const received: FeedResponse[] = [];
+    stream.next(r => received.push(r));
+    const factManager = options.factManager ?? new FakeFactManager();
+    const session = new FeedStreamSession(
+        query,
+        factManager as unknown as FactManager,
+        feedDefinition,
+        start,
+        givenHash,
+        stream,
+        options.initialBookmark ?? "",
+        "regression-conn",
+        options.config ?? {}
+    );
+    return { session, stream, received, factManager };
+}
+
+async function settle(): Promise<void> {
+    for (let i = 0; i < 20; i++) {
+        await new Promise<void>(resolve => setImmediate(resolve));
+    }
+}
+
+describe("FeedStreamSession regression", () => {
+    it("delivers a post-SYNC update on a paginating store and advances the bookmark", async () => {
+        const A = ref("Test.Post", "a");
+        const B = ref("Test.Post", "b");
+        // A realistic paginating store keyed by bookmark: A is history at "";
+        // after SYNC, B is delivered past "bm1" and the bookmark moves to "bm2".
+        const query = jest.fn(async (bookmark: string) => {
+            if (bookmark === "") return page("bm1", [tuple(A)]);
+            if (bookmark === "bm1") return emptyPage("bm1");
+            if (bookmark === "bm1+B") return page("bm2", [tuple(B)]);
+            return emptyPage("bm2");
+        });
+        // Second cycle needs a distinct bookmark once B is available; emulate
+        // that by having onInverseMatch flip the store's view.
+        let bReady = false;
+        const wrapped = jest.fn(async (bookmark: string) => {
+            if (bookmark === "bm1" && bReady) return page("bm2", [tuple(B)]);
+            return query(bookmark);
+        });
+        const { session, received } = makeSession(wrapped, { config: { pageDelayEvery: 0 } });
+
+        session.start();
+        await settle();
+        // Backfill delivered A then a SYNC frame at bm1.
+        expect(received).toEqual([
+            { references: [A], bookmark: "bm1" },
+            { references: [], bookmark: "bm1" }
+        ]);
+
+        // A real-time update arrives after SYNC.
+        bReady = true;
+        session.onInverseMatch([B]);
+        await settle();
+
+        expect(received.slice(2)).toEqual([
+            { references: [B], bookmark: "bm2" },
+            { references: [], bookmark: "bm2" }
+        ]);
+        // Bookmark advanced monotonically and never regressed.
+        expect(received.map(r => r.bookmark)).toEqual(["bm1", "bm1", "bm2", "bm2"]);
+    });
+
+    it("re-delivers a fact that was dropped as stale once a later trigger makes it completable", async () => {
+        const A = ref("Test.Post", "a");
+        let completable = false;
+        // Bookmark-respecting store: A only becomes visible past "" once its
+        // tuple is completable; afterward the bookmark advances to "bm1".
+        const query = jest.fn(async (bookmark: string) => {
+            if (completable && bookmark === "") return page("bm1", [tuple(A)]);
+            return emptyPage(bookmark === "" ? "" : "bm1");
+        });
+        const { session, received } = makeSession(query);
+
+        // First trigger: A's tuple cannot complete, so it is dropped and a
+        // SYNC frame is emitted without ever delivering A.
+        session.onInverseMatch([A]);
+        await settle();
+        expect(received).toEqual([{ references: [], bookmark: "" }]);
+        expect(session.waitlistSize).toBe(0);
+
+        // A becomes completable; a later trigger re-adds it and it is delivered.
+        completable = true;
+        session.onInverseMatch([A]);
+        await settle();
+        expect(received.slice(1)).toEqual([
+            { references: [A], bookmark: "bm1" },
+            { references: [], bookmark: "bm1" }
+        ]);
+    });
+
+    it("does not run concurrent cycles under a burst of triggers", async () => {
+        let concurrent = 0;
+        let maxConcurrent = 0;
+        const query = jest.fn(async () => {
+            concurrent++;
+            maxConcurrent = Math.max(maxConcurrent, concurrent);
+            await new Promise<void>(resolve => setImmediate(resolve));
+            concurrent--;
+            return emptyPage("");
+        });
+        const A = ref("Test.Post", "a");
+        const { session } = makeSession(query);
+
+        session.start();
+        for (let i = 0; i < 8; i++) {
+            session.onInverseMatch([A]);
+        }
+        await settle();
+
+        expect(maxConcurrent).toBe(1);
+    });
+
+    it("streams nothing once disposed while a query is in flight", async () => {
+        const A = ref("Test.Post", "a");
+        let resolveQuery: (value: FeedResult) => void = () => { };
+        const query = jest.fn(() => new Promise<FeedResult>(resolve => { resolveQuery = resolve; }));
+        const { session, received } = makeSession(query);
+
+        session.start();
+        // Let the cycle enter the awaited query.
+        await new Promise<void>(resolve => setImmediate(resolve));
+
+        // Dispose mid-query, then let the query resolve with a full page.
+        session.dispose();
+        resolveQuery(page("bm1", [tuple(A)]));
+        await settle();
+
+        // The post-dispose page must not be streamed.
+        expect(received).toEqual([]);
+    });
+});