benjivers/notes Public Public: anyone can read this; nobody can change it.

/**

 * Every door answers as the table says. The test acts as each identity the

 * contract declares — on a note that names them and on one that names

 * someone else — and calls the real actions. A rule written by hand in an

 * action, or a cell changed without its door, fails here.

 */

import { expect, test } from "bun:test";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import {

  addNote,

  deleteNote,

  getAudit,

  getNote,

  listAudit,

  listNotes,

  updateNote,

} from "./actions.ts";

import { record } from "./audit.ts";

import { actingAs, identities, table, type Verb } from "./can.ts";

import { contract } from "./contract.ts";

import { openDb } from "./db.ts";

import type { Who } from "./who.ts";

const db = openDb(mkdtempSync(join(tmpdir(), "app-contract-")));

/** The identity the evaluator acts as, as the forge would have signed it. */

function whoIs(identity: string): Who {

  const { actor } = actingAs(contract, identity);

  const role = actor.roles[0];

  if (actor.id === null || (role !== "user" && role !== "admin"))

    return { role: "anon" };

  return { role, id: actor.id, name: identity };

}

let made = 0;

const noteBy = (authorId: string): number =>

  db

    .query<

      { id: number },

      [string, string]

    >("INSERT INTO note (title, body, author_id, author_name) VALUES (?2, 'n', ?1, ?1) RETURNING id")

    .get(authorId, `n${++made}`)!.id;

const auditRow = (): number => {

  record(db, {

    who: { role: "anon" },

    resource: "note",

    verb: "create",

    outcome: "signin_required",

  });

  return db.query<{ id: number }, []>("SELECT max(id) AS id FROM audit").get()!

    .id;

};

/** One door per verb an action serves: did it let `who` through, on `row`? */

const doors: Record<

  string,

  Partial<Record<Verb, (who: Who, authorId: string) => boolean>>

> = {

  note: {

    create: (who) => addNote(db, who, { body: "hello" }).ok,

    list: (who) => listNotes(db, who).ok,

    read: (who, authorId) => getNote(db, who, { id: noteBy(authorId) }).ok,

    update: (who, authorId) =>

      updateNote(db, who, { id: noteBy(authorId), body: "changed" }).ok,

    delete: (who, authorId) => deleteNote(db, who, { id: noteBy(authorId) }).ok,

  },

  // The trail is written by the app itself, never through a door: there

  // is no action that creates, changes or removes a row of it.

  audit: {

    list: (who) => listAudit(db, who).ok,

    read: (who) => getAudit(db, who, { id: auditRow() }).ok,

    create: () => false,

    update: () => false,

    delete: () => false,

  },

};

test("the contract names the identities the forge signs", () => {

  expect(identities(contract).sort()).toEqual(["admin", "anon", "user"]);

});

test("every resource in the contract has every door here", () => {

  expect(Object.keys(doors).sort()).toEqual(

    Object.keys(contract.resources).sort(),

  );

  for (const resource of Object.keys(contract.resources))

    expect(Object.keys(doors[resource] ?? {}).sort()).toEqual([

      "create",

      "delete",

      "list",

      "read",

      "update",

    ]);

});

test("every door answers as the table says, as every identity", () => {

  let asked = 0;

  for (const cell of table(contract)) {

    const door = doors[cell.resource]?.[cell.verb];

    if (door === undefined) continue;

    const who = whoIs(cell.as);

    const { mine, theirs } = actingAs(contract, cell.as);

    const onMine = door(who, String(mine["author_id"]));

    const onTheirs = door(who, String(theirs["author_id"]));

    const said = `${cell.resource}.${cell.verb} as ${cell.as}`;

    asked++;

    if (cell.answer === "yes")

      expect([said, onMine, onTheirs]).toEqual([said, true, true]);

    else if (cell.answer === "no")

      expect([said, onMine, onTheirs]).toEqual([said, false, false]);

    else if (cell.verb === "list") expect([said, onMine]).toEqual([said, true]);

    else expect([said, onMine, onTheirs]).toEqual([said, true, false]);

  }

  expect(asked).toBeGreaterThan(0);

});