jinaga-server 3.5.5 → 3.6.0

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
+};

package/integration-test/jinaga-test/subscription-late-auth.test.js

@@ -0,0 +1,245 @@
+const request = require('supertest');
+const { buildModel, User } = require('jinaga');
+const { createSubscriptionApp, asUser, randomSuffix } = require('./subscription-helpers');
+
+class Company {
+  static Type = "LateAuth.Company";
+  type = Company.Type;
+  constructor(creator, identifier) {
+    this.creator = creator;
+    this.identifier = identifier;
+  }
+}
+
+class Office {
+  static Type = "LateAuth.Office";
+  type = Office.Type;
+  constructor(company, name) {
+    this.company = company;
+    this.name = name;
+  }
+}
+
+class Administrator {
+  static Type = "LateAuth.Administrator";
+  type = Administrator.Type;
+  constructor(company, user, createdAt) {
+    this.company = company;
+    this.user = user;
+    this.createdAt = createdAt;
+  }
+}
+
+const model = buildModel(b => b
+  .type(User)
+  .type(Company, m => m.predecessor("creator", User))
+  .type(Office, m => m.predecessor("company", Company))
+  .type(Administrator, m => m
+    .predecessor("company", Company)
+    .predecessor("user", User))
+);
+
+function authorization(a) {
+  return a
+    .any(User)
+    .any(Company)
+    .any(Office)
+    .any(Administrator);
+}
+
+function distribution(d) {
+  return d
+    .share(model.given(Company).match((c, facts) =>
+      facts.ofType(Office).join(o => o.company, c)
+    ))
+    .with(model.given(Company).match((c, facts) =>
+      facts.ofType(Administrator)
+        .join(a => a.company, c)
+        .selectMany(a => facts.ofType(User).join(u => u, a.user))
+    ));
+}
+
+function officeSpecText(companyHash) {
+  // The `p1` label name mirrors what `model.given(Company)` produces
+  // so the distribution engine can lift the rule's path conditions onto
+  // the subscription's given during intersectForSubscribe.
+  return `let p1: ${Company.Type} = #${companyHash}\n` +
+    `(p1: ${Company.Type}) {\n` +
+    `    o: ${Office.Type} [\n` +
+    `        o->company: ${Company.Type} = p1\n` +
+    `    ]\n` +
+    `} => o`;
+}
+
+jest.setTimeout(30000);
+
+describe('Subscription late-auth recovery', () => {
+  let app, withSession, close;
+
+  beforeEach(async () => {
+    ({ app, withSession, close } = await createSubscriptionApp({
+      model, authorization, distribution
+    }));
+  });
+
+  afterEach(async () => {
+    if (close) await close();
+  });
+
+  it('accepts the subscription with an empty page when the subscriber is not yet authorized', async () => {
+    const { companyHash } = await asUser(withSession, 'creator-1-' + randomSuffix(), async (creatorJ) => {
+      const { userFact: creatorFact } = await creatorJ.login();
+      const company = await creatorJ.fact(new Company(creatorFact, 'Acme-' + randomSuffix()));
+      await creatorJ.fact(new Office(company, 'HQ'));
+      return { companyHash: creatorJ.hash(company) };
+    });
+
+    const subscriberId = 'subscriber-1-' + randomSuffix();
+    await asUser(withSession, subscriberId, async (j) => { await j.login(); });
+
+    // POST /feeds must NOT 403: distribution rule denies the subscriber,
+    // but the server intersects the spec so the subscription can be
+    // activated once the authorizing fact arrives.
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', subscriberId)
+      .send(officeSpecText(companyHash));
+
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+    expect(Array.isArray(feeds)).toBe(true);
+    expect(feeds.length).toBeGreaterThan(0);
+
+    // Polling the cached hash returns an empty page — the pre-existing
+    // Office is hidden until the lifted auth condition is satisfied.
+    const pollResponse = await request(app)
+      .get(`/feeds/${feeds[0]}`)
+      .set('x-test-user-id', subscriberId);
+
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    const officeRefs = (body.references || []).filter(r => r.type === Office.Type);
+    expect(officeRefs).toHaveLength(0);
+  });
+
+  it('surfaces existing offices once the authorizing fact arrives', async () => {
+    let companyValue;
+    let creatorFactValue;
+    const creatorId = 'creator-2-' + randomSuffix();
+    const { companyHash, officeHash } = await asUser(withSession, creatorId, async (creatorJ) => {
+      const { userFact: creatorFact } = await creatorJ.login();
+      creatorFactValue = creatorFact;
+      const company = await creatorJ.fact(new Company(creatorFact, 'Acme-' + randomSuffix()));
+      companyValue = company;
+      const office = await creatorJ.fact(new Office(company, 'HQ'));
+      return {
+        companyHash: creatorJ.hash(company),
+        officeHash: creatorJ.hash(office)
+      };
+    });
+
+    const subscriberId = 'subscriber-2-' + randomSuffix();
+    const subscriberFact = await asUser(withSession, subscriberId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    // Subscribe BEFORE the authorizing fact exists so the cached hash is
+    // an intersected (lifted) spec — feedPreVerified will then serve it.
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', subscriberId)
+      .send(officeSpecText(companyHash));
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+    const feedHash = feeds[0];
+
+    // Initial poll: empty (lifted condition not yet satisfied).
+    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 === Office.Type)).toHaveLength(0);
+
+    // Creator grants the subscriber the Administrator role.
+    await asUser(withSession, creatorId, async (creatorJ) => {
+      await creatorJ.fact(new Administrator(companyValue, subscriberFact, new Date('2026-05-27')));
+    });
+
+    // Re-poll without propagating the prior bookmark. The intersected
+    // spec is 2-given, and the bookmark-extended SQL path currently
+    // generates a WHERE constraint on the second given without a
+    // corresponding JOIN (a separate PostgresStore bug). Re-querying
+    // from the beginning sidesteps that and still validates the
+    // contract — the office surfaces once the lifted condition holds.
+    const secondPoll = await request(app)
+      .get(`/feeds/${feedHash}`)
+      .set('x-test-user-id', subscriberId);
+    expect(secondPoll.status).toBe(200);
+    const secondBody = JSON.parse(secondPoll.text);
+    const officeRefs = (secondBody.references || []).filter(r => r.type === Office.Type);
+    expect(officeRefs.map(r => r.hash)).toContain(officeHash);
+  });
+
+  it('does not let a different authenticated user reuse an intersected feed hash', async () => {
+    let companyValue;
+    const creatorId = 'creator-3-' + randomSuffix();
+    const { companyHash } = await asUser(withSession, creatorId, async (creatorJ) => {
+      const { userFact: creatorFact } = await creatorJ.login();
+      const company = await creatorJ.fact(new Company(creatorFact, 'Acme-' + randomSuffix()));
+      companyValue = company;
+      await creatorJ.fact(new Office(company, 'HQ'));
+      return { companyHash: creatorJ.hash(company) };
+    });
+
+    const aliceId = 'alice-3-' + randomSuffix();
+    const aliceFact = await asUser(withSession, aliceId, async (j) => {
+      const { userFact } = await j.login();
+      return userFact;
+    });
+
+    // Mallory must exist in the keystore for the polling auth path to
+    // resolve her user fact during the distribution check.
+    const malloryId = 'mallory-3-' + randomSuffix();
+    await asUser(withSession, malloryId, async (j) => { await j.login(); });
+
+    // Alice subscribes while NOT yet an admin so the cached hash is the
+    // intersected (Alice-owned) spec.
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', aliceId)
+      .send(officeSpecText(companyHash));
+    const { feeds } = JSON.parse(feedsResponse.text);
+    const intersectedHash = feeds[0];
+
+    // Now grant Alice the Administrator role so her intersected spec
+    // actually produces rows.
+    await asUser(withSession, creatorId, async (creatorJ) => {
+      await creatorJ.fact(new Administrator(companyValue, aliceFact, new Date('2026-05-27')));
+    });
+
+    // Alice can read her own intersected feed and sees the office.
+    const alicePoll = await request(app)
+      .get(`/feeds/${intersectedHash}`)
+      .set('x-test-user-id', aliceId);
+    expect(alicePoll.status).toBe(200);
+    const aliceBody = JSON.parse(alicePoll.text);
+    expect((aliceBody.references || []).some(r => r.type === Office.Type)).toBe(true);
+
+    // Mallory polls the same hash. The router routes her through the
+    // normal distribution check (cached owner is Alice, not Mallory),
+    // which denies her — the polling path returns an empty page rather
+    // than leaking Alice's data.
+    const malloryPoll = await request(app)
+      .get(`/feeds/${intersectedHash}`)
+      .set('x-test-user-id', malloryId);
+    expect(malloryPoll.status).toBe(200);
+    const malloryBody = JSON.parse(malloryPoll.text);
+    const malloryOffices = (malloryBody.references || []).filter(r => r.type === Office.Type);
+    expect(malloryOffices).toHaveLength(0);
+  });
+});

package/integration-test/jinaga-test/subscription-no-rule.test.js

@@ -0,0 +1,137 @@
+const request = require('supertest');
+const { buildModel, User } = require('jinaga');
+const { createSubscriptionApp, asUser, randomSuffix } = require('./subscription-helpers');
+
+// Validates the "keep subscriptions alive across distribution failures"
+// contract: when no distribution rule covers the requested spec, the
+// /feeds endpoint accepts the subscription and polling returns an empty
+// page rather than 403. /read still 403s because reads are one-shot.
+
+class Company {
+  static Type = "NoRule.Company";
+  type = Company.Type;
+  constructor(creator, identifier) {
+    this.creator = creator;
+    this.identifier = identifier;
+  }
+}
+
+class Office {
+  static Type = "NoRule.Office";
+  type = Office.Type;
+  constructor(company, name) {
+    this.company = company;
+    this.name = name;
+  }
+}
+
+class Administrator {
+  static Type = "NoRule.Administrator";
+  type = Administrator.Type;
+  constructor(company, user, createdAt) {
+    this.company = company;
+    this.user = user;
+    this.createdAt = createdAt;
+  }
+}
+
+const model = buildModel(b => b
+  .type(User)
+  .type(Company, m => m.predecessor("creator", User))
+  .type(Office, m => m.predecessor("company", Company))
+  .type(Administrator, m => m
+    .predecessor("company", Company)
+    .predecessor("user", User))
+);
+
+function authorization(a) {
+  return a
+    .any(User)
+    .any(Company)
+    .any(Office)
+    .any(Administrator);
+}
+
+// Distribution covers Office only. Administrator queries fall outside
+// any rule.
+function distribution(d) {
+  return d
+    .share(model.given(Company).match((c, facts) =>
+      facts.ofType(Office).join(o => o.company, c)
+    ))
+    .with(model.given(Company).match((c, facts) =>
+      facts.ofType(Administrator)
+        .join(a => a.company, c)
+        .selectMany(a => facts.ofType(User).join(u => u, a.user))
+    ));
+}
+
+function administratorSpecText(companyHash) {
+  return `let p1: ${Company.Type} = #${companyHash}\n` +
+    `(p1: ${Company.Type}) {\n` +
+    `    a: ${Administrator.Type} [\n` +
+    `        a->company: ${Company.Type} = p1\n` +
+    `    ]\n` +
+    `} => a`;
+}
+
+describe('Subscription when no distribution rule applies', () => {
+  let app, withSession, close;
+  let companyHash;
+  let subscriberId;
+
+  beforeEach(async () => {
+    ({ app, withSession, close } = await createSubscriptionApp({
+      model, authorization, distribution
+    }));
+
+    const creatorId = 'creator-norule-' + randomSuffix();
+    ({ companyHash } = await asUser(withSession, creatorId, async (creatorJ) => {
+      const { userFact: creatorFact } = await creatorJ.login();
+      const company = await creatorJ.fact(new Company(creatorFact, 'Acme-' + randomSuffix()));
+      return { companyHash: creatorJ.hash(company) };
+    }));
+
+    subscriberId = 'subscriber-norule-' + randomSuffix();
+    await asUser(withSession, subscriberId, async (j) => { await j.login(); });
+  });
+
+  afterEach(async () => {
+    if (close) await close();
+  });
+
+  it('accepts /feeds and returns an empty page on poll', async () => {
+    // No rule covers Administrator. intersectForSubscribe also has
+    // nothing to intersect against. The contract is: /feeds succeeds,
+    // polling returns an empty page so the client keeps waiting.
+    const feedsResponse = await request(app)
+      .post('/feeds')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', subscriberId)
+      .send(administratorSpecText(companyHash));
+
+    expect(feedsResponse.status).toBe(200);
+    const { feeds } = JSON.parse(feedsResponse.text);
+    expect(Array.isArray(feeds)).toBe(true);
+    expect(feeds.length).toBeGreaterThan(0);
+
+    const pollResponse = await request(app)
+      .get(`/feeds/${feeds[0]}`)
+      .set('x-test-user-id', subscriberId);
+    expect(pollResponse.status).toBe(200);
+    const body = JSON.parse(pollResponse.text);
+    expect(body.references || []).toEqual([]);
+  });
+
+  it('still returns 403 from /read for the same spec', async () => {
+    // Reads are one-shot — there is no "wait until authorized later"
+    // semantic, so Forbidden propagates as 403.
+    const readResponse = await request(app)
+      .post('/read')
+      .set('Content-Type', 'text/plain')
+      .set('x-test-user-id', subscriberId)
+      .send(administratorSpecText(companyHash));
+
+    expect(readResponse.status).toBe(403);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinaga-server",
-  "version": "3.5.5",
+  "version": "3.6.0",
   "description": "Data management for web and mobile applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,7 +49,7 @@
   "dependencies": {
     "csv-stringify": "^6.6.0",
     "express": "^4.21.2",
-    "jinaga": "^6.7.25",
+    "jinaga": "^6.8.0",
     "pg": "^8.13.1"
   }
 }