jinaga-server 3.5.5 → 3.7.0

package/integration-test/jinaga-test/distribution-negating-feed.test.js

@@ -0,0 +1,202 @@
+const request = require('supertest');
+const { buildModel, User } = require('jinaga');
+const { createSubscriptionApp, asUser, randomSuffix } = require('./subscription-helpers');
+
+// Exercises a distribution rule whose user-spec uses notExists — the
+// "negating-feed authorization (#196)" dimension the PR closes by
+// having DistributionEngine.canDistributeTo fall back to
+// canAuthorizeByComposition. We avoid the late-auth/intersection path
+// here so the test is hitting canDistributeTo (via feedWithDistribution)
+// directly with a negating user-spec.
+
+jest.setTimeout(30000);
+
+class Group {
+  static Type = "NegatingFeed.Group";
+  type = Group.Type;
+  constructor(creator, name) {
+    this.creator = creator;
+    this.name = name;
+  }
+}
+
+class Member {
+  static Type = "NegatingFeed.Member";
+  type = Member.Type;
+  constructor(group, user) {
+    this.group = group;
+    this.user = user;
+  }
+}
+
+class MemberRemoved {
+  static Type = "NegatingFeed.Member.Removed";
+  type = MemberRemoved.Type;
+  constructor(member) {
+    this.member = member;
+  }
+}
+
+class Content {
+  static Type = "NegatingFeed.Content";
+  type = Content.Type;
+  constructor(group, body) {
+    this.group = group;
+    this.body = body;
+  }
+}
+
+const model = buildModel(b => b
+  .type(User)
+  .type(Group, m => m.predecessor("creator", User))
+  .type(Member, m => m
+    .predecessor("group", Group)
+    .predecessor("user", User))
+  .type(MemberRemoved, m => m.predecessor("member", Member))
+  .type(Content, m => m.predecessor("group", Group))
+);
+
+function authorization(a) {
+  return a
+    .any(User)
+    .any(Group)
+    .any(Member)
+    .any(MemberRemoved)
+    .any(Content);
+}
+
+// Share Content of a Group with users who are currently Members — i.e.
+// have a Member fact with no MemberRemoved successor. The notExists
+// here is what makes this a "negating-feed" user-spec.
+function distribution(d) {
+  return d
+    .share(model.given(Group).match((g, facts) =>
+      facts.ofType(Content).join(c => c.group, g)
+    ))
+    .with(model.given(Group).match((g, facts) =>
+      facts.ofType(Member)
+        .join(m => m.group, g)
+        .notExists(m => facts.ofType(MemberRemoved).join(r => r.member, m))
+        .selectMany(m => facts.ofType(User).join(u => u, m.user))
+    ));
+}
+
+function contentSpecText(groupHash) {
+  return `let p1: ${Group.Type} = #${groupHash}\n` +
+    `(p1: ${Group.Type}) {\n` +
+    `    c: ${Content.Type} [\n` +
+    `        c->group: ${Group.Type} = p1\n` +
+    `    ]\n` +
+    `} => c`;
+}
+
+describe('Distribution rule with negating feed (notExists)', () => {
+  let app, withSession, close;
+  let groupValue, groupHash, contentHash;
+  let creatorId;
+
+  beforeEach(async () => {
+    ({ app, withSession, close } = await createSubscriptionApp({
+      model, authorization, distribution
+    }));
+
+    creatorId = 'group-creator-' + randomSuffix();
+    ({ groupHash, contentHash } = await asUser(withSession, creatorId, async (creatorJ) => {
+      const { userFact: creatorFact } = await creatorJ.login();
+      const group = await creatorJ.fact(new Group(creatorFact, 'g-' + randomSuffix()));
+      groupValue = group;
+      const content = await creatorJ.fact(new Content(group, 'shared body'));
+      return {
+        groupHash: creatorJ.hash(group),
+        contentHash: creatorJ.hash(content)
+      };
+    }));
+  });
+
+  afterEach(async () => {
+    if (close) await close();
+  });
+
+  it('delivers content to a current member', async () => {
+    const memberId = 'group-member-' + randomSuffix();
+    const memberFact = await asUser(withSession, memberId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    // Grant membership BEFORE subscribing so the distribution check
+    // (notExists removed → current member) passes and we never hit
+    // intersection. This makes the test target canDistributeTo
+    // directly via feedWithDistribution.
+    await asUser(withSession, creatorId, async (j) => {
+      await j.fact(new Member(groupValue, memberFact));
+    });
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', memberId)
+      .send(contentSpecText(groupHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+
+    const pollResponse = await request(app)
+      .get(`/feeds/${feeds[0]}`)
+      .set('x-test-user-id', memberId);
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    const visible = (body.references || []).filter(r => r.type === Content.Type);
+    expect(visible.map(r => r.hash)).toContain(contentHash);
+  });
+
+  it('hides content from a removed member', async () => {
+    const memberId = 'group-removed-' + randomSuffix();
+    const memberFact = await asUser(withSession, memberId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    // Add then remove the membership. The notExists branch flips,
+    // canDistributeTo denies, and the poll returns an empty page.
+    let memberValue;
+    await asUser(withSession, creatorId, async (j) => {
+      memberValue = await j.fact(new Member(groupValue, memberFact));
+      await j.fact(new MemberRemoved(memberValue));
+    });
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', memberId)
+      .send(contentSpecText(groupHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+
+    const pollResponse = await request(app)
+      .get(`/feeds/${feeds[0]}`)
+      .set('x-test-user-id', memberId);
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    expect((body.references || []).filter(r => r.type === Content.Type)).toHaveLength(0);
+  });
+
+  it('hides content from a never-member', async () => {
+    const outsiderId = 'group-outsider-' + randomSuffix();
+    await asUser(withSession, outsiderId, async (j) => { /* login only */ });
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', outsiderId)
+      .send(contentSpecText(groupHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+
+    const pollResponse = await request(app)
+      .get(`/feeds/${feeds[0]}`)
+      .set('x-test-user-id', outsiderId);
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    expect((body.references || []).filter(r => r.type === Content.Type)).toHaveLength(0);
+  });
+});

package/integration-test/jinaga-test/feed-existential-input.test.js

@@ -0,0 +1,241 @@
+const request = require('supertest');
+const { buildModel, User } = require('jinaga');
+const { createSubscriptionApp, asUser, randomSuffix } = require('./subscription-helpers');
+
+// Exercises a PostgresStore feed-SQL bug surfaced by the Copilot review
+// on PR #164: when a path condition inside an existential references a
+// given for the first time, the type+hash filter for that given is
+// registered on `ExistentialConditionDescription.inputs`. The result-SQL
+// generator emits those, but the feed-SQL generator silently drops them.
+// The effect is a notExists that ignores its parameterized filter — the
+// existential matches ANY fact with the right roles regardless of the
+// given's identity, so the outer match is filtered out incorrectly.
+
+jest.setTimeout(30000);
+
+class Workspace {
+  static Type = "ExistInput.Workspace";
+  type = Workspace.Type;
+  constructor(creator, name) {
+    this.creator = creator;
+    this.name = name;
+  }
+}
+
+class WorkspaceAccess {
+  static Type = "ExistInput.WorkspaceAccess";
+  type = WorkspaceAccess.Type;
+  constructor(workspace, user) {
+    this.workspace = workspace;
+    this.user = user;
+  }
+}
+
+class Document {
+  static Type = "ExistInput.Document";
+  type = Document.Type;
+  constructor(workspace, title) {
+    this.workspace = workspace;
+    this.title = title;
+  }
+}
+
+class Restriction {
+  static Type = "ExistInput.Restriction";
+  type = Restriction.Type;
+  // Marks a document as hidden from a specific user.
+  constructor(document, user) {
+    this.document = document;
+    this.user = user;
+  }
+}
+
+const model = buildModel(b => b
+  .type(User)
+  .type(Workspace, m => m.predecessor("creator", User))
+  .type(WorkspaceAccess, m => m
+    .predecessor("workspace", Workspace)
+    .predecessor("user", User))
+  .type(Document, m => m.predecessor("workspace", Workspace))
+  .type(Restriction, m => m
+    .predecessor("document", Document)
+    .predecessor("user", User))
+);
+
+function authorization(a) {
+  return a
+    .any(User)
+    .any(Workspace)
+    .any(WorkspaceAccess)
+    .any(Document)
+    .any(Restriction);
+}
+
+// 2-given rule whose share has the SAME shape as the user's spec
+// (documents in workspace w, except those restricted for user u).
+// The `with` rule grants access to any user that has a
+// WorkspaceAccess for the workspace. The rule's share spec is what
+// has to skeleton-match the user's spec for canDistributeTo to pass.
+function distribution(d) {
+  return d
+    .share(model.given(Workspace, User).match((w, u, facts) =>
+      facts.ofType(Document).join(d => d.workspace, w)
+        .notExists(d => facts.ofType(Restriction)
+          .join(r => r.document, d)
+          .join(r => r.user, u))
+    ))
+    .with(model.given(Workspace, User).match((w, u, facts) =>
+      facts.ofType(WorkspaceAccess)
+        .join(a => a.workspace, w)
+        .join(a => a.user, u)
+        .selectMany(a => facts.ofType(User).join(x => x, a.user))
+    ));
+}
+
+// Subscription: documents in workspace p1 that have not been
+// restricted for user p2. The given p2 is referenced FOR THE
+// FIRST TIME inside the notExists — this is what triggers the
+// "existential inputs dropped" bug in the feed-SQL generator.
+function docSpecText(workspaceHash, userHash) {
+  return `let p1: ${Workspace.Type} = #${workspaceHash}\n` +
+    `let p2: ${User.Type} = #${userHash}\n` +
+    `(p1: ${Workspace.Type}, p2: ${User.Type}) {\n` +
+    `    d: ${Document.Type} [\n` +
+    `        d->workspace: ${Workspace.Type} = p1\n` +
+    `        !E {\n` +
+    `            r: ${Restriction.Type} [\n` +
+    `                r->document: ${Document.Type} = d\n` +
+    `                r->user: ${User.Type} = p2\n` +
+    `            ]\n` +
+    `        }\n` +
+    `    ]\n` +
+    `} => d`;
+}
+
+describe('Feed SQL: existential references a given referenced only inside the notExists', () => {
+  let app, withSession, close;
+  let workspaceValue, workspaceHash, documentValue, documentHash;
+  let creatorId;
+
+  beforeEach(async () => {
+    ({ app, withSession, close } = await createSubscriptionApp({
+      model, authorization, distribution
+    }));
+
+    creatorId = 'ei-creator-' + randomSuffix();
+    ({ workspaceHash, documentHash } = await asUser(withSession, creatorId, async (j) => {
+      const { userFact: creatorFact } = await j.login();
+      const workspace = await j.fact(new Workspace(creatorFact, 'w-' + randomSuffix()));
+      workspaceValue = workspace;
+      const document = await j.fact(new Document(workspace, 'doc-' + randomSuffix()));
+      documentValue = document;
+      return {
+        workspaceHash: j.hash(workspace),
+        documentHash: j.hash(document)
+      };
+    }));
+  });
+
+  afterEach(async () => {
+    if (close) await close();
+  });
+
+  it('does not let one user\'s Restriction hide a document from a different user', async () => {
+    // Alice and Bob both get WorkspaceAccess so the distribution
+    // check passes for each of them directly (no intersection).
+    const aliceId = 'ei-alice-' + randomSuffix();
+    const aliceFact = await asUser(withSession, aliceId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    const bobId = 'ei-bob-' + randomSuffix();
+    const bobFact = await asUser(withSession, bobId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    await asUser(withSession, creatorId, async (j) => {
+      await j.fact(new WorkspaceAccess(workspaceValue, aliceFact));
+      await j.fact(new WorkspaceAccess(workspaceValue, bobFact));
+      // Restriction targets Bob ONLY. Alice's view must not be
+      // affected — her notExists should remain true.
+      await j.fact(new Restriction(documentValue, bobFact));
+    });
+
+    const aliceHash = await asUser(withSession, aliceId, async (j) => j.hash(aliceFact));
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', aliceId)
+      .send(docSpecText(workspaceHash, aliceHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+    expect(feeds.length).toBeGreaterThan(0);
+
+    // A spec with notExists splits into a negating feed and a main
+    // feed (with the notExists applied). The bug lives in the main
+    // feed's SQL, so aggregate references across all feeds.
+    const aggregated = [];
+    for (const feedHash of feeds) {
+      const pollResponse = await request(app)
+        .get(`/feeds/${feedHash}`)
+        .set('x-test-user-id', aliceId);
+      expect(pollResponse.status).toBe(200);
+      const body = JSON.parse(pollResponse.text);
+      aggregated.push(...(body.references || []));
+    }
+    const docs = aggregated.filter(r => r.type === Document.Type);
+    // Without the fix the main feed's existential ignores its
+    // `user = p2` filter and matches Bob's Restriction, so Alice's
+    // notExists evaluates false and she gets no documents.
+    expect(docs.map(r => r.hash)).toContain(documentHash);
+  });
+
+  it('hides a document from the user whose Restriction exists', async () => {
+    // Companion case: when the Restriction IS for the polling user,
+    // the notExists must evaluate false and the document must be
+    // filtered out.
+    const carolId = 'ei-carol-' + randomSuffix();
+    const carolFact = await asUser(withSession, carolId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    await asUser(withSession, creatorId, async (j) => {
+      await j.fact(new WorkspaceAccess(workspaceValue, carolFact));
+      await j.fact(new Restriction(documentValue, carolFact));
+    });
+
+    const carolHash = await asUser(withSession, carolId, async (j) => j.hash(carolFact));
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', carolId)
+      .send(docSpecText(workspaceHash, carolHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+
+    // The main feed must NOT include the document for Carol. The
+    // negating feed legitimately surfaces the Restriction (a fact
+    // proving the condition false) along with the Document so the
+    // client can react — exclude those by only counting Documents
+    // returned without an accompanying Restriction.
+    let mainDocHashes = [];
+    for (const feedHash of feeds) {
+      const pollResponse = await request(app)
+        .get(`/feeds/${feedHash}`)
+        .set('x-test-user-id', carolId);
+      expect(pollResponse.status).toBe(200);
+      const body = JSON.parse(pollResponse.text);
+      const refs = body.references || [];
+      const hasRestriction = refs.some(r => r.type === Restriction.Type);
+      if (!hasRestriction) {
+        mainDocHashes.push(...refs.filter(r => r.type === Document.Type).map(r => r.hash));
+      }
+    }
+    expect(mainDocHashes).not.toContain(documentHash);
+  });
+});

package/integration-test/jinaga-test/feeds-endpoint.test.js

@@ -0,0 +1,140 @@
+const request = require('supertest');
+const { buildModel, User } = require('jinaga');
+const { createSubscriptionApp, asUser, randomSuffix } = require('./subscription-helpers');
+
+// Baseline coverage for POST /feeds and GET /feeds/:hash that did not
+// exist in the integration suite before. Independent of PR #163's
+// late-auth contracts, this catches schema/router-wiring regressions on
+// the subscription endpoints.
+
+class Root {
+  static Type = "FeedsEndpoint.Root";
+  type = Root.Type;
+  constructor(creator, identifier) {
+    this.creator = creator;
+    this.identifier = identifier;
+  }
+}
+
+class Item {
+  static Type = "FeedsEndpoint.Item";
+  type = Item.Type;
+  constructor(root, name) {
+    this.root = root;
+    this.name = name;
+  }
+}
+
+const model = buildModel(b => b
+  .type(User)
+  .type(Root, m => m.predecessor("creator", User))
+  .type(Item, m => m.predecessor("root", Root))
+);
+
+function authorization(a) {
+  return a.any(User).any(Root).any(Item);
+}
+
+function itemSpecText(rootHash) {
+  return `let r: ${Root.Type} = #${rootHash}\n` +
+    `(r: ${Root.Type}) {\n` +
+    `    i: ${Item.Type} [\n` +
+    `        i->root: ${Root.Type} = r\n` +
+    `    ]\n` +
+    `} => i`;
+}
+
+describe('Feeds endpoint baseline', () => {
+  let app, withSession, close;
+  let rootHash;
+  const itemHashes = [];
+  let writerId;
+
+  beforeEach(async () => {
+    ({ app, withSession, close } = await createSubscriptionApp({
+      model, authorization
+    }));
+
+    writerId = 'feeds-writer-' + randomSuffix();
+    rootHash = await asUser(withSession, writerId, async (j) => {
+      const { userFact } = await j.login();
+      const root = await j.fact(new Root(userFact, 'r-' + randomSuffix()));
+      itemHashes.length = 0;
+      for (let i = 0; i < 3; i++) {
+        const item = await j.fact(new Item(root, `item-${i}`));
+        itemHashes.push(j.hash(item));
+      }
+      return j.hash(root);
+    });
+  });
+
+  afterEach(async () => {
+    if (close) await close();
+  });
+
+  it('POST /feeds returns a non-empty hash list for a valid spec', async () => {
+    const response = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', writerId)
+      .send(itemSpecText(rootHash));
+
+    expect(response.status).toBe(200);
+    const body = JSON.parse(response.text);
+    expect(Array.isArray(body.feeds)).toBe(true);
+    expect(body.feeds.length).toBeGreaterThan(0);
+    body.feeds.forEach(hash => {
+      expect(typeof hash).toBe('string');
+      expect(hash.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('GET /feeds/:hash returns existing items with a bookmark', async () => {
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', writerId)
+      .send(itemSpecText(rootHash));
+    const { feeds } = JSON.parse(feedsResponse.text);
+
+    const pollResponse = await request(app)
+      .get(`/feeds/${feeds[0]}`)
+      .set('x-test-user-id', writerId);
+
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    const itemRefs = (body.references || []).filter(r => r.type === Item.Type);
+    expect(itemRefs.map(r => r.hash).sort()).toEqual([...itemHashes].sort());
+    expect(typeof body.bookmark).toBe('string');
+  });
+
+  it('GET /feeds/:hash returns 404 for an unknown hash', async () => {
+    const response = await request(app)
+      .get('/feeds/this-hash-does-not-exist-' + randomSuffix())
+      .set('x-test-user-id', writerId);
+
+    expect(response.status).toBe(404);
+  });
+
+  it('POST /feeds with malformed text returns 400', async () => {
+    const response = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', writerId)
+      .send('this is not a specification');
+
+    // SpecificationParser raises an Invalid error which the router
+    // translates into a 400.
+    expect(response.status).toBe(400);
+  });
+
+  it('OPTIONS /feeds advertises Accept-Post', async () => {
+    const response = await request(app)
+      .options('/feeds');
+
+    expect(response.status).toBe(204);
+    const acceptPost = response.headers['accept-post'];
+    expect(acceptPost).toBeDefined();
+    expect(acceptPost).toContain('text/plain');
+  });
+});

package/integration-test/jinaga-test/package-lock.json

@@ -14,7 +14,7 @@
         "express": "^4.21.2",
         "jest": "^29.7.0",
         "jest-compact-reporter": "^1.2.9",
-        "jinaga": "^6.7.25",
+        "jinaga": "^6.8.3",
         "node-forge": "^1.3.0",
         "pg": "^8.13.1"
       },
@@ -3195,9 +3195,9 @@
       }
     },
     "node_modules/jinaga": {
-      "version": "6.7.25",
-      "resolved": "https://registry.npmjs.org/jinaga/-/jinaga-6.7.25.tgz",
-      "integrity": "sha512-J+9KjHYdDkemO5xTau20P+NV1p2DMFodFwE/ulBFTYLA+4jG7YFOxEYN9n6Irn0Wv3itz5PvRUMpVEmzovj2Hw==",
+      "version": "6.8.3",
+      "resolved": "https://registry.npmjs.org/jinaga/-/jinaga-6.8.3.tgz",
+      "integrity": "sha512-v3dvRQKlXj++uT9D/AxFfRIeKwzitqYAs9Fxx5Q+wbCyYM+wHv4eRH9qCRcOIjv/jnl8iO/3vGGFZz+z2eMQgw==",
       "license": "MIT",
       "dependencies": {
         "@stablelib/base64": "^1.0.1",

package/integration-test/jinaga-test/package.json

@@ -8,7 +8,8 @@
     "test:verbose": "jest --silent=false --verbose false"
   },
   "jest": {
-    "verbose": false
+    "verbose": false,
+    "testTimeout": 30000
   },
   "author": "Michael L Perry",
   "license": "MIT",
@@ -18,7 +19,7 @@
     "express": "^4.21.2",
     "jest": "^29.7.0",
     "jest-compact-reporter": "^1.2.9",
-    "jinaga": "^6.7.25",
+    "jinaga": "^6.8.3",
     "node-forge": "^1.3.0",
     "pg": "^8.13.1"
   },