jinaga-server 3.7.3 → 3.7.5

package/test/http/errorStatusMappingSpec.ts

@@ -0,0 +1,351 @@
+import express from "express";
+import { AddressInfo } from "net";
+import { Server } from "http";
+
+import {
+    Authorization,
+    AuthorizationRules,
+    buildModel,
+    dehydrateFact,
+    DistributionRules,
+    FactEnvelope,
+    FactManager,
+    FactReference,
+    FeedCache,
+    Invalid,
+    MemoryStore,
+    NetworkNoOp,
+    ObservableSource,
+    PassThroughFork,
+    PredecessorNotResolvedError,
+    User
+} from "jinaga";
+
+import { AuthorizationKeystore, SubscriptionAuthorizer } from "../../src/authorization/authorization-keystore";
+import { HttpRouter, RequestUser } from "../../src/http/router";
+import { MemoryKeystore } from "../../src/memory/memory-keystore";
+
+class Workspace {
+    static Type = "ErrorStatus.Workspace" as const;
+    public type = Workspace.Type;
+    constructor(public owner: User, public identifier: string) { }
+}
+
+class Application {
+    static Type = "ErrorStatus.Application" as const;
+    public type = Application.Type;
+    constructor(public workspace: Workspace, public name: string) { }
+}
+
+const model = buildModel(b => b
+    .type(User)
+    .type(Workspace, w => w.predecessor("owner", User))
+    .type(Application, a => a.predecessor("workspace", Workspace))
+);
+
+const ownerIdentity = { provider: "mock", id: "owner" };
+
+const requestUser: RequestUser = {
+    provider: ownerIdentity.provider,
+    id: ownerIdentity.id,
+    profile: {} as any
+};
+
+async function createHarness() {
+    const store = new MemoryStore();
+    const keystore = new MemoryKeystore();
+    const ownerFact = await keystore.getOrCreateUserFact(ownerIdentity);
+    const owner = new User(ownerFact.fields.publicKey);
+
+    const factManager = new FactManager(
+        new PassThroughFork(store),
+        new ObservableSource(store),
+        store,
+        new NetworkNoOp(),
+        []
+    );
+
+    const authorizationRules = new AuthorizationRules(model)
+        .any(User.Type)
+        .any(Workspace.Type)
+        .type(Application, app => app.workspace.owner);
+    const authorization = new AuthorizationKeystore(
+        factManager, store, keystore, authorizationRules, new DistributionRules([]));
+    const router = new HttpRouter(factManager, authorization, new FeedCache(), "*");
+
+    return { store, authorization, router, owner };
+}
+
+// A batch holding a successor whose predecessors are in neither the batch nor
+// storage. jinaga's AuthorizationEngine detects this in its topological sort
+// and reports it as a plain Error.
+function unclosedBatch(owner: User): FactEnvelope[] {
+    const records = dehydrateFact(new Application(new Workspace(owner, "workspace-1"), "application-1"));
+    return records
+        .filter(fact => fact.type === Application.Type)
+        .map(fact => ({ fact, signatures: [] }));
+}
+
+function graphSourceOf(envelopes: FactEnvelope[]) {
+    return {
+        read: async (onEnvelopes: (envelopes: FactEnvelope[]) => Promise<void>) => {
+            await onEnvelopes(envelopes);
+        }
+    };
+}
+
+// A router whose only job is to reject the authorization call with a chosen
+// error, so the translation can be exercised for a route whose input grammar
+// cannot provoke the error on its own.
+function createRouterWithFailingSave(error: Error): HttpRouter {
+    const store = new MemoryStore();
+    const factManager = new FactManager(
+        new PassThroughFork(store), new ObservableSource(store), store, new NetworkNoOp(), []);
+    const keystore = new MemoryKeystore();
+    const authorization = {
+        getOrCreateUserFact: (identity: any) => keystore.getOrCreateUserFact(identity),
+        save: () => Promise.reject(error)
+    } as unknown as Authorization & SubscriptionAuthorizer;
+    return new HttpRouter(factManager, authorization, new FeedCache(), "*");
+}
+
+async function captureError(action: () => Promise<unknown>): Promise<any> {
+    try {
+        await action();
+    } catch (error) {
+        return error;
+    }
+    throw new Error("Expected the operation to fail, but it succeeded.");
+}
+
+// Issue #182 findings 1 and 2. These drive the real AuthorizationEngine rather
+// than a hand-written message, so the classification is pinned to what jinaga
+// actually throws. That mattered concretely: the original version of this
+// translation matched the engine's prose, and 6.11.3 reworded it one release
+// later — these tests failed rather than letting the 400 regress to a 500 in
+// production. The unresolved-predecessor path is now an instanceof check on
+// the typed error jinaga.js#234 introduced.
+describe("save authorization error translation", () => {
+    it("reports an unresolved predecessor from the real engine as a typed error", async () => {
+        const { authorization, owner } = await createHarness();
+
+        const error = await captureError(() =>
+            authorization.save(ownerIdentity, unclosedBatch(owner)));
+
+        // The untranslated baseline: still not an Invalid, so handleError alone
+        // would map it to 500 — but now it carries the structured detail the
+        // translation reads instead of parsing prose.
+        expect(error).toBeInstanceOf(PredecessorNotResolvedError);
+        expect(error).not.toBeInstanceOf(Invalid);
+        expect(error.missingPredecessors.map((r: FactReference) => r.type)).toContain(Workspace.Type);
+        expect(error.unresolvedFacts.map((r: FactReference) => r.type)).toContain(Application.Type);
+    });
+
+    it("translates the unresolved predecessor to Invalid on /save", async () => {
+        const { router, owner } = await createHarness();
+
+        const error = await captureError(() =>
+            (router as any).save(requestUser, graphSourceOf(unclosedBatch(owner))));
+
+        expect(error).toBeInstanceOf(Invalid);
+        // Names the predecessor that is actually missing — the structured
+        // fields make this possible, where the prose match could only report
+        // the successors that failed to sort.
+        expect(error.message).toContain(Workspace.Type);
+        expect(error.message).toContain("was not found in storage and was not included in the request");
+    });
+
+    it("translates the unresolved predecessor to Invalid on /write", async () => {
+        // The declaration grammar /write accepts cannot express a dangling
+        // predecessor, so the engine error is captured from the reachable
+        // /save path and replayed here. The route still needs the translation:
+        // it makes the same authorization call, and this keeps both routes
+        // reading one upstream error type.
+        const { authorization, owner } = await createHarness();
+        const engineError = await captureError(() =>
+            authorization.save(ownerIdentity, unclosedBatch(owner)));
+
+        const router = createRouterWithFailingSave(engineError);
+        const declaration =
+            `let workspace: ${Workspace.Type} = { owner: me, identifier: "workspace-1" }\n` +
+            `let application: ${Application.Type} = { workspace: workspace, name: "application-1" }\n`;
+
+        const error = await captureError(() => (router as any).write(requestUser, declaration));
+
+        expect(error).toBeInstanceOf(Invalid);
+        expect(error.message).toContain("was not found in storage and was not included in the request");
+    });
+
+    it("still translates the authorization-rule shape fixed by issue #175", async () => {
+        const router = createRouterWithFailingSave(
+            new Error("The fact ErrorStatus.Workspace:abc123 is not defined."));
+
+        const error = await captureError(() =>
+            (router as any).save(requestUser, graphSourceOf([])));
+
+        expect(error).toBeInstanceOf(Invalid);
+        expect(error.message).toContain("ErrorStatus.Workspace:abc123 is required to authorize this save");
+    });
+});
+
+// Issue #182 findings 3 and 4, exercised over real HTTP so the assertions are
+// on the status line a client actually receives.
+describe("HTTP status mapping", () => {
+    let server: Server;
+    let baseUrl: string;
+
+    async function listen(app: express.Express) {
+        server = app.listen(0);
+        await new Promise<void>(resolve => server.once("listening", () => resolve()));
+        const port = (server.address() as AddressInfo).port;
+        baseUrl = `http://127.0.0.1:${port}`;
+    }
+
+    afterEach(async () => {
+        if (server) {
+            await new Promise<void>(resolve => server.close(() => resolve()));
+        }
+    });
+
+    describe("with no body parser registered", () => {
+        beforeEach(async () => {
+            const { router } = await createHarness();
+            const app = express();
+            app.use(router.handler);
+            await listen(app);
+        });
+
+        // Each of these parses the body synchronously in the handler. Express
+        // used to hand the throw to its default error handler, reporting the
+        // client's malformed request as a 500.
+        it.each([
+            ["/write", "text/plain"],
+            ["/read", "text/plain"],
+            ["/feeds", "text/plain"],
+            ["/load", "application/json"]
+        ])("answers 400 for %s when the body cannot be read", async (path, contentType) => {
+            const response = await fetch(`${baseUrl}${path}`, {
+                method: "POST",
+                headers: { "Content-Type": contentType },
+                body: contentType === "application/json" ? "{}" : "anything"
+            });
+
+            expect(response.status).toBe(400);
+        });
+
+        // The text/plain-only routes name the parser the caller is missing,
+        // rather than falling back to parseString's generic content-type
+        // message.
+        it.each(["/write", "/read"])("names express.text() in the 400 body for %s", async (path) => {
+            const response = await fetch(`${baseUrl}${path}`, {
+                method: "POST",
+                headers: { "Content-Type": "text/plain" },
+                body: "anything"
+            });
+
+            expect(await response.text()).toContain("express.text()");
+        });
+
+        // Saying what arrived tells the caller which end is misconfigured.
+        it("names the Content-Type that was received", async () => {
+            const response = await fetch(`${baseUrl}/write`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: "{}"
+            });
+
+            expect(await response.text()).toContain("Received Content-Type: application/json");
+        });
+
+        it("says so when no Content-Type was received", async () => {
+            const response = await fetch(`${baseUrl}/write`, {
+                method: "POST",
+                body: new Blob(["anything"])
+            });
+
+            expect(await response.text()).toContain("No Content-Type header was received");
+        });
+
+        // The echoed Content-Type is client-supplied, so it must not be able to
+        // carry markup into the body.
+        it("neutralizes markup in the echoed Content-Type", async () => {
+            const response = await fetch(`${baseUrl}/write`, {
+                method: "POST",
+                headers: { "Content-Type": "text/plain<script>alert(1)</script>" },
+                body: "anything"
+            });
+            const body = await response.text();
+
+            expect(response.status).toBe(400);
+            expect(body).not.toContain("<script>");
+            expect(body).toContain("&lt;script&gt;");
+        });
+
+        it("caps the length of the echoed Content-Type", async () => {
+            const response = await fetch(`${baseUrl}/write`, {
+                method: "POST",
+                headers: { "Content-Type": `text/plain;padding=${"x".repeat(500)}` },
+                body: "anything"
+            });
+            const body = await response.text();
+
+            expect(response.status).toBe(400);
+            expect(body).toContain("…");
+            expect(body.length).toBeLessThan(300);
+        });
+
+        it("marks error responses nosniff", async () => {
+            const response = await fetch(`${baseUrl}/write`, {
+                method: "POST",
+                headers: { "Content-Type": "text/plain" },
+                body: "anything"
+            });
+
+            expect(response.status).toBe(400);
+            expect(response.headers.get("x-content-type-options")).toBe("nosniff");
+        });
+    });
+
+    it("answers 500 without echoing the internal error message", async () => {
+        const store = new MemoryStore();
+        const factManager = new FactManager(
+            new PassThroughFork(store), new ObservableSource(store), store, new NetworkNoOp(), []);
+        const secret = "connection to postgres://internal-host:5432 refused";
+        const failingAuthorization = {
+            load: () => Promise.reject(new Error(secret))
+        } as unknown as Authorization & SubscriptionAuthorizer;
+        const router = new HttpRouter(factManager, failingAuthorization, new FeedCache(), "*");
+
+        const app = express();
+        app.use(express.json());
+        app.use(router.handler);
+        await listen(app);
+
+        const response = await fetch(`${baseUrl}/load`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ references: [] })
+        });
+        const body = await response.text();
+
+        expect(response.status).toBe(500);
+        expect(body).toBe("Internal server error");
+        expect(body).not.toContain("internal-host");
+        // A plain-text body labelled text/html invites a browser to render it.
+        expect(response.headers.get("content-type")).toContain("text/plain");
+        expect(response.headers.get("x-content-type-options")).toBe("nosniff");
+    });
+
+    it("answers 404 with a distinguishable body for a feed route miss", async () => {
+        const { router } = await createHarness();
+        const app = express();
+        app.use(router.handler);
+        await listen(app);
+
+        // A hash the feed cache has never seen resolves to FeedNotFound, which
+        // is a different 404 from the route miss below.
+        const cacheMiss = await fetch(`${baseUrl}/feeds/unknownhash`);
+        expect(cacheMiss.status).toBe(404);
+        expect(await cacheMiss.text()).toBe("feed_not_found");
+    });
+});

package/test/postgres/userGivenFeedSqlSpec.ts

@@ -0,0 +1,115 @@
+import { buildFeeds, dehydrateReference, getAllFactTypes, getAllRoles, Specification, SpecificationParser } from "jinaga";
+
+import { addFactType, addRole, emptyFactTypeMap, emptyRoleMap, FactTypeMap, getFactTypeId, RoleMap } from "../../src/postgres/maps";
+import { sqlFromFeed } from "../../src/postgres/specification-sql";
+
+// Regression coverage for jinaga-server#179.
+//
+// The issue named two candidate loci for a `Jinaga.User`-given feed returning
+// empty despite matching data: the distribution decision (jinaga.js) and the
+// Postgres feed SQL (this repo, `sqlFromFeed`). These tests pin down the
+// second: the feed SQL generated for a specification whose given is typed
+// `Jinaga.User` is structurally identical to the SQL for the same join shape
+// against any other given type. There is no `Jinaga.User` special-casing in
+// jinaga-server's query generation, so the empty-result trigger does not live
+// here.
+
+function parseSpecification(input: string): Specification {
+    const parser = new SpecificationParser(input);
+    parser.skipWhitespace();
+    return parser.parseSpecification();
+}
+
+function buildMaps(specification: Specification): { factTypes: FactTypeMap; roleMap: RoleMap } {
+    // Assign deterministic type ids in first-seen order so two specifications
+    // with the same shape but different type names produce identical parameter
+    // sequences. Filter the synthetic "Unknown" fact type and "unknown" role
+    // name (matching the other Postgres SQL generator specs) so they cannot
+    // shift the id assignment. Roles get ids offset well past the type ids.
+    const factTypes = getAllFactTypes(specification)
+        .filter(factType => factType !== 'Unknown')
+        .reduce((f, factType, i) => addFactType(f, factType, i + 1), emptyFactTypeMap());
+    const roleMap = getAllRoles(specification)
+        .filter(role => role.name !== 'unknown')
+        .reduce((r, role, i) => {
+            const factTypeId = getFactTypeId(factTypes, role.successorType);
+            if (!factTypeId) {
+                return r;
+            }
+            return addRole(r, factTypeId, role.name, i + 100);
+        }, emptyRoleMap());
+    return { factTypes, roleMap };
+}
+
+// Pure: generates the feed SQL for a single-feed specification. All assertions
+// live in the tests (or beforeAll) so a parse/build failure surfaces as a test
+// failure rather than a suite-collection error.
+function feedSqlFor(descriptiveString: string, startType: string) {
+    const specification = parseSpecification(descriptiveString);
+    const { factTypes, roleMap } = buildMaps(specification);
+    const feeds = buildFeeds(specification);
+    const start = [dehydrateReference({ type: startType, key: "value" })];
+    const query = sqlFromFeed(feeds[0], start, "public", "", 100, factTypes, roleMap);
+    return { query, feedCount: feeds.length, factTypes };
+}
+
+// The canonical "owned by me" shape: a successor edged to the given user
+// through a role named `owner`.
+const USER_GIVEN_SPEC = `
+    (user: Jinaga.User) {
+        activity: Networking.Activity [
+            activity->owner: Jinaga.User = user
+        ]
+    }`;
+
+// The identical join shape rooted at a non-user given.
+const ACTIVITY_GIVEN_SPEC = `
+    (activity: Networking.Activity) {
+        log: Networking.ActivityCrmLog [
+            log->activity: Networking.Activity = activity
+        ]
+    }`;
+
+describe("Jinaga.User-given feed SQL (issue #179)", () => {
+    let userGiven: ReturnType<typeof feedSqlFor>;
+    let activityGiven: ReturnType<typeof feedSqlFor>;
+
+    beforeAll(() => {
+        userGiven = feedSqlFor(USER_GIVEN_SPEC, "Jinaga.User");
+        activityGiven = feedSqlFor(ACTIVITY_GIVEN_SPEC, "Networking.Activity");
+        // Both shapes must reduce to a single feed for the comparison to be
+        // apples-to-apples.
+        expect(userGiven.feedCount).toBe(1);
+        expect(activityGiven.feedCount).toBe(1);
+    });
+
+    it("produces a satisfiable, single feed query for a Jinaga.User given", () => {
+        // A satisfiable query is the whole point: a null query here would be
+        // the silent-empty the issue describes. The given's type is loaded and
+        // the predecessor edge on `owner` is generated.
+        expect(userGiven.query).not.toBeNull();
+        expect(userGiven.query!.sql).toContain("f1.fact_type_id = $1 AND f1.hash = $2");
+        expect(userGiven.query!.sql).toContain("public.edge");
+        expect(userGiven.query!.labels.length).toBe(1);
+    });
+
+    it("generates SQL structurally identical to a non-user given of the same shape", () => {
+        // No Jinaga.User special-casing: the two SQL strings match exactly.
+        expect(userGiven.query).not.toBeNull();
+        expect(activityGiven.query).not.toBeNull();
+        expect(userGiven.query!.sql).toEqual(activityGiven.query!.sql);
+    });
+
+    it("binds the given type id (from the fact-type map) and hash as the leading parameters", () => {
+        // The given fact type participates in the WHERE clause like any other —
+        // it is not dropped or defaulted to a constant for Jinaga.User. Derive
+        // the expected id from the map built for this spec so the assertion is
+        // not coupled to getAllFactTypes ordering.
+        const userReference = dehydrateReference({ type: "Jinaga.User", key: "value" });
+        const expectedTypeId = getFactTypeId(userGiven.factTypes, "Jinaga.User");
+        expect(expectedTypeId).toBeDefined();
+        expect(userGiven.query).not.toBeNull();
+        expect(userGiven.query!.parameters[0]).toBe(expectedTypeId);
+        expect(userGiven.query!.parameters[1]).toBe(userReference.hash);
+    });
+});