jinaga-server 3.5.4 → 3.6.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.13",
+        "jinaga": "^6.8.0",
         "node-forge": "^1.3.0",
         "pg": "^8.13.1"
       },
@@ -3195,9 +3195,9 @@
       }
     },
     "node_modules/jinaga": {
-      "version": "6.7.13",
-      "resolved": "https://registry.npmjs.org/jinaga/-/jinaga-6.7.13.tgz",
-      "integrity": "sha512-WhSg3bWvUr1WnC4lnpzswJIZ45bMWxRlKXlEhOsofI86jXJSH7tHUqXWKZ9UJihc5/8iGxJUnM65zWZmPa+aFA==",
+      "version": "6.8.0",
+      "resolved": "https://registry.npmjs.org/jinaga/-/jinaga-6.8.0.tgz",
+      "integrity": "sha512-YN2CtA3PcIDpLR/2fQQTSX5IeoxynEVXLtvHWfK2bUpDrPzfDjsxc8ALbN7OZlEVMeOZuxvtQdgHYH79qqe0iQ==",
       "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.13",
+    "jinaga": "^6.8.0",
     "node-forge": "^1.3.0",
     "pg": "^8.13.1"
   },

package/integration-test/jinaga-test/subscription-anchor-arrival.test.js

@@ -0,0 +1,129 @@
+const request = require('supertest');
+const { buildModel, dehydrateFact, User } = require('jinaga');
+const { createSubscriptionApp, asUser, randomSuffix } = require('./subscription-helpers');
+
+// Validates the polling-side contract that subscribing to a spec whose
+// given fact has not yet been stored is accepted, and that the data
+// surfaces once the given (and a matching descendant) lands. In the
+// streaming path this is what the anchor listener wakes up; the polling
+// path achieves the same outcome by re-querying the store, so a Postgres-
+// backed test here guards the store/feed query against a missing given
+// reference.
+
+class Note {
+  static Type = "AnchorArrival.Note";
+  type = Note.Type;
+  constructor(author, body) {
+    this.author = author;
+    this.body = body;
+  }
+}
+
+const model = buildModel(b => b
+  .type(User)
+  .type(Note, m => m.predecessor("author", User))
+);
+
+function authorization(a) {
+  return a.any(User).any(Note);
+}
+
+function noteSpecText(userHash) {
+  return `let p: Jinaga.User = #${userHash}\n` +
+    `(p: Jinaga.User) {\n` +
+    `    n: ${Note.Type} [\n` +
+    `        n->author: Jinaga.User = p\n` +
+    `    ]\n` +
+    `} => n`;
+}
+
+describe('Subscription with not-yet-stored given fact', () => {
+  let app, withSession, close;
+
+  beforeEach(async () => {
+    ({ app, withSession, close } = await createSubscriptionApp({
+      model, authorization
+    }));
+  });
+
+  afterEach(async () => {
+    if (close) await close();
+  });
+
+  it('accepts the subscription and surfaces data once the given and a descendant arrive', async () => {
+    // Hand-craft a User whose hash is known but whose fact has not been
+    // saved. This stands in for the "given fact arrives later" scenario
+    // — the streamFeed path would activate via the anchor listener; the
+    // polling path picks it up naturally on the next poll.
+    const externalUser = new User('anchor-arrival-key-' + randomSuffix());
+    const userHash = dehydrateFact(externalUser)
+      .find(f => f.type === 'Jinaga.User').hash;
+
+    const subscriberId = 'anchor-subscriber-' + randomSuffix();
+    await asUser(withSession, subscriberId, async (j) => { await j.login(); });
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', subscriberId)
+      .send(noteSpecText(userHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+    expect(feeds.length).toBeGreaterThan(0);
+    const feedHash = feeds[0];
+
+    // Poll #1: the given fact does not exist yet, so there can be no
+    // descendants — the page is empty but the server must not 404 or
+    // error.
+    const firstPoll = await request(app)
+      .get(`/feeds/${feedHash}`)
+      .set('x-test-user-id', subscriberId);
+    expect(firstPoll.status).toBe(200);
+    const firstBody = JSON.parse(firstPoll.text);
+    expect((firstBody.references || []).filter(r => r.type === Note.Type)).toHaveLength(0);
+    const firstBookmark = firstBody.bookmark || '';
+
+    // Save the given User fact AND a Note that joins to it.
+    // j.fact(new Note(externalUser, ...)) recursively saves both, so
+    // when polling resumes both the anchor and its descendant exist.
+    const writerId = 'anchor-writer-' + randomSuffix();
+    let noteHash;
+    await asUser(withSession, writerId, async (writerJ) => {
+      const note = await writerJ.fact(new Note(externalUser, 'first body'));
+      noteHash = writerJ.hash(note);
+    });
+
+    const secondPoll = await request(app)
+      .get(`/feeds/${feedHash}`)
+      .query({ b: firstBookmark })
+      .set('x-test-user-id', subscriberId);
+    expect(secondPoll.status).toBe(200);
+    const secondBody = JSON.parse(secondPoll.text);
+    const noteRefs = (secondBody.references || []).filter(r => r.type === Note.Type);
+    expect(noteRefs.map(r => r.hash)).toContain(noteHash);
+  });
+
+  it('returns an empty page (not 404) when the given fact never arrives', async () => {
+    const phantomUser = new User('phantom-key-' + randomSuffix());
+    const userHash = dehydrateFact(phantomUser)
+      .find(f => f.type === 'Jinaga.User').hash;
+
+    const subscriberId = 'phantom-subscriber-' + randomSuffix();
+    await asUser(withSession, subscriberId, async (j) => { await j.login(); });
+
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', subscriberId)
+      .send(noteSpecText(userHash));
+    const { feeds } = JSON.parse(feedsResponse.text);
+    const feedHash = feeds[0];
+
+    const pollResponse = await request(app)
+      .get(`/feeds/${feedHash}`)
+      .set('x-test-user-id', subscriberId);
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    expect((body.references || []).filter(r => r.type === Note.Type)).toHaveLength(0);
+  });
+});

package/integration-test/jinaga-test/subscription-helpers.js

@@ -0,0 +1,60 @@
+const express = require('express');
+const { JinagaServer } = require('./jinaga-server');
+
+const host = "db";
+const connectionString = `postgresql://dev:devpw@${host}:5432/integrationtest`;
+
+function authMiddleware(req, res, next) {
+  const userId = req.header('x-test-user-id');
+  if (userId) {
+    req.user = {
+      provider: 'test',
+      id: userId,
+      profile: { displayName: userId }
+    };
+  }
+  next();
+}
+
+async function createSubscriptionApp(config) {
+  const instance = JinagaServer.create({
+    pgKeystore: connectionString,
+    pgStore: connectionString,
+    ...config
+  });
+
+  const app = express();
+  app.use(express.json());
+  app.use(express.text());
+  app.use(authMiddleware);
+  app.use(instance.handler);
+
+  await instance.j.local();
+  return { app, ...instance };
+}
+
+async function asUser(withSession, userId, callback) {
+  let result;
+  await withSession(
+    { user: { provider: 'test', id: userId, profile: { displayName: userId } } },
+    async (j) => {
+      // Ensure the user fact is registered in the keystore so AuthenticationSession
+      // can sign facts and the router's getUserFact succeeds on later requests.
+      await j.login();
+      result = await callback(j);
+    }
+  );
+  return result;
+}
+
+function randomSuffix() {
+  return Math.random().toString(36).substring(2, 10);
+}
+
+module.exports = {
+  connectionString,
+  authMiddleware,
+  createSubscriptionApp,
+  asUser,
+  randomSuffix
+};