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

/**

 * Shared folders. A space is a folder of a git repository on the forge —

 * `docs/` of `ben/brainstorm`, say — that its members write in together.

 * Its notes are ordinary notes whose vault is the space (author_id

 * `space:<id>`), so links, backlinks, tags, search and the graph work in it

 * exactly as they do in a personal vault, and never reach across: a

 * personal vault and a space share nothing. Each note keeps its file's

 * path, and `src/sync.ts` keeps the folder and the repository in step.

 *

 * Who is in: the person who made it (an app admin — the repository token

 * is theirs, so nobody else may point it at a repository), and whoever

 * opened its join link while it was on. The owner can turn the link off,

 * make a new one, and remove members; a member can leave.

 */

import type { Database } from "bun:sqlite";

import { randomBytes } from "node:crypto";

import { emit } from "./live.ts";

import type { Failure, Result } from "./actions.ts";

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

export interface Space {

  readonly id: number;

  readonly name: string;

  /** `owner/name` on the forge. */

  readonly repo: string;

  readonly branch: string;

  /** The folder in the repository the notes live in, `""` for its root. */

  readonly folder: string;

  readonly owner_id: string;

  readonly owner_name: string;

  readonly join_code: string | null;

  /** The commit the notes were last read from. */

  readonly head: string | null;

  readonly synced_at: string | null;

  readonly sync_error: string | null;

  readonly created_at: string;

}

export interface Member {

  readonly who_id: string;

  readonly who_name: string;

  readonly joined_at: string;

}

const ok = <T>(value: T): Result<T> => ({ ok: true, value });

const fail = <T>(error: Failure, message: string): Result<T> => ({ ok: false, error, message });

/** The vault a space's notes are kept in: what their author_id says. */

export const spaceVault = (id: number): string => `space:${id}`;

/** The space a vault is, when it is one. */

export const spaceOf = (vault: string): number | undefined => {

  const m = /^space:(\d+)$/.exec(vault);

  return m === null ? undefined : Number(m[1]);

};

/** A space's address in the app. */

export const spaceHref = (id: number): string => `/s/${id}`;

export const findSpace = (db: Database, id: number): Space | undefined =>

  Number.isInteger(id)

    ? (db.query<Space, [number]>("SELECT * FROM space WHERE id = ?1").get(id) ?? undefined)

    : undefined;

export const isMember = (db: Database, id: number, who: Who): boolean =>

  who.role !== "anon" &&

  db

    .query<{ n: number }, [number, string]>(

      "SELECT 1 AS n FROM space_member WHERE space_id = ?1 AND who_id = ?2",

    )

    .get(id, who.id) !== null;

export const members = (db: Database, id: number): Member[] =>

  db

    .query<Member, [number]>(

      "SELECT who_id, who_name, joined_at FROM space_member WHERE space_id = ?1 ORDER BY joined_at, who_name",

    )

    .all(id);

/** Tell every member of a space what changed in it. */

export function tellSpace(db: Database, id: number, type: string, data: unknown): void {

  for (const m of members(db, id)) emit(type, data, m.who_id);

}

/** The spaces `who` is in, by name. */

export const mySpaces = (db: Database, who: Who): Space[] =>

  who.role === "anon"

    ? []

    : db

        .query<Space, [string]>(

          "SELECT s.* FROM space s JOIN space_member m ON m.space_id = s.id WHERE m.who_id = ?1 ORDER BY s.name COLLATE NOCASE",

        )

        .all(who.id);

/** A space, for one of its members. */

export function getSpace(db: Database, who: Who, id: number): Result<Space> {

  if (who.role === "anon") return fail("signin_required", "Sign in to open this folder.");

  const space = findSpace(db, id);

  // Whoever is not in it learns nothing about whether it exists.

  if (space === undefined || !isMember(db, id, who)) return fail("not_found", "No such shared folder.");

  return ok(space);

}

/** A space, for its owner. */

function owned(db: Database, who: Who, id: number): Result<Space> {

  const space = getSpace(db, who, id);

  if (!space.ok) return space;

  if (who.role === "anon" || space.value.owner_id !== who.id)

    return fail("forbidden", "Only the folder's owner can do that.");

  return space;

}

const code = (): string => randomBytes(18).toString("base64url");

// What a repository, branch and folder may be called: the forge's own rules, roughly.

const REPO = /^[\w.-]+\/[\w.-]+$/;

const BRANCH = /^(?!-)(?!.*\.\.)[\w./-]{1,100}$/;

/** A file or folder name a note can have: one segment, nothing a filesystem or a link would trip on. */

export function cleanSegment(raw: string): Result<string> {

  const s = raw.replace(/\s+/g, " ").trim();

  if (s === "" || s.length > 120) return fail("invalid", "A name is 1 to 120 characters.");

  if (s.startsWith(".")) return fail("invalid", "A name cannot start with a dot.");

  if (/[\/\\:*?"<>|\[\]#^\u0000-\u001f]/.test(s))

    return fail("invalid", "A name cannot hold / \\ : * ? \" < > | [ ] # or ^.");

  return ok(s);

}

/** A folder path, `a/b`: each segment clean, no empty ones. `""` is the top. */

export function cleanFolder(raw: string): Result<string> {

  const parts = raw.split("/").map((p) => p.trim()).filter((p) => p !== "");

  const out: string[] = [];

  for (const p of parts) {

    const clean = cleanSegment(p);

    if (!clean.ok) return clean;

    out.push(clean.value);

  }

  return ok(out.join("/"));

}

const join = (...parts: string[]): string => parts.filter((p) => p !== "").join("/");

/** The file a note titled `title` in `folder` (relative to the space's own) is kept in. */

export const fileOf = (space: Pick<Space, "folder">, folder: string, title: string): string =>

  join(space.folder, folder, `${title}.md`);

/** The folder a file is in, relative to the space's own. */

export function folderOf(space: Pick<Space, "folder">, path: string): string {

  const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";

  if (space.folder === "") return dir;

  return dir === space.folder ? "" : dir.slice(space.folder.length + 1);

}

/** A file's note title: its name, without `.md`. */

export const titleOfPath = (path: string): string =>

  path.slice(path.lastIndexOf("/") + 1).replace(/\.md$/i, "");

/** Make a space: an app admin points it at a repository folder, and is its first member. */

export function createSpace(

  db: Database,

  who: Who,

  input: { name: string; repo: string; branch?: string; folder?: string },

): Result<Space> {

  if (who.role === "anon") return fail("signin_required", "Sign in to make a shared folder.");

  if (who.role !== "admin")

    return fail("forbidden", "Only an app admin can connect a repository — it is written to with their token.");

  const name = input.name.replace(/\s+/g, " ").trim();

  if (name === "" || name.length > 80) return fail("invalid", "A name is 1 to 80 characters.");

  const repo = input.repo.trim().replace(/^\/+|\/+$/g, "");

  if (!REPO.test(repo)) return fail("invalid", "The repository is owner/name, as on the forge.");

  const branch = (input.branch ?? "").trim() || "main";

  if (!BRANCH.test(branch)) return fail("invalid", "That is not a branch name.");

  const folder = cleanFolder(input.folder ?? "");

  if (!folder.ok) return folder;

  const taken = db

    .query<{ id: number }, [string, string, string]>(

      "SELECT id FROM space WHERE repo = ?1 AND branch = ?2 AND folder = ?3",

    )

    .get(repo, branch, folder.value);

  if (taken !== null) return fail("invalid", "That folder is already shared here.");

  const space = db.transaction(() => {

    const made = db

      .query<Space, [string, string, string, string, string, string, string]>(

        "INSERT INTO space (name, repo, branch, folder, owner_id, owner_name, join_code) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7) RETURNING *",

      )

      .get(name, repo, branch, folder.value, who.id, who.name, code())!;

    db.query("INSERT INTO space_member (space_id, who_id, who_name) VALUES (?1, ?2, ?3)").run(

      made.id,

      who.id,

      who.name,

    );

    return made;

  })();

  return ok(space);

}

/** Open a join link: whoever is signed in becomes a member. */

export function joinSpace(db: Database, who: Who, input: { code: string }): Result<Space> {

  if (who.role === "anon") return fail("signin_required", "Sign in, then open the link again.");

  const space =

    input.code === ""

      ? null

      : db.query<Space, [string]>("SELECT * FROM space WHERE join_code = ?1").get(input.code);

  if (space === null) return fail("not_found", "That link has been turned off, or was never one.");

  db.query(

    "INSERT INTO space_member (space_id, who_id, who_name) VALUES (?1, ?2, ?3) ON CONFLICT (space_id, who_id) DO UPDATE SET who_name = excluded.who_name",

  ).run(space.id, who.id, who.name);

  tellSpace(db, space.id, "space.changed", { id: space.id });

  return ok(space);

}

/** Turn the join link off, or on with a new address (the old one stops working). */

export function setLink(db: Database, who: Who, input: { id: number; on: boolean }): Result<Space> {

  const space = owned(db, who, input.id);

  if (!space.ok) return space;

  return ok(

    db

      .query<Space, [string | null, number]>("UPDATE space SET join_code = ?1 WHERE id = ?2 RETURNING *")

      .get(input.on ? code() : null, input.id)!,

  );

}

/** The owner removes a member, or a member leaves. The owner stays. */

export function removeMember(

  db: Database,

  who: Who,

  input: { id: number; member: string },

): Result<{ id: number }> {

  const space = getSpace(db, who, input.id);

  if (!space.ok) return space;

  if (who.role === "anon") return fail("signin_required", "Sign in first.");

  const self = input.member === who.id;

  if (!self && space.value.owner_id !== who.id)

    return fail("forbidden", "Only the folder's owner can remove someone.");

  if (input.member === space.value.owner_id)

    return fail("invalid", "The owner can't leave their own folder — delete it instead.");

  db.query("DELETE FROM space_member WHERE space_id = ?1 AND who_id = ?2").run(input.id, input.member);

  emit("space.changed", { id: input.id }, input.member);

  tellSpace(db, input.id, "space.changed", { id: input.id });

  return ok({ id: input.id });

}

/** Stop sharing: the space and its copy of the notes go; the repository keeps every file. */

export function deleteSpace(db: Database, who: Who, input: { id: number }): Result<{ id: number }> {

  const space = owned(db, who, input.id);

  if (!space.ok) return space;

  const everyone = members(db, input.id);

  db.transaction(() => {

    db.query("DELETE FROM note WHERE author_id = ?1").run(spaceVault(input.id));

    db.query("DELETE FROM space WHERE id = ?1").run(input.id);

  })();

  for (const m of everyone) emit("space.changed", { id: input.id }, m.who_id);

  return ok({ id: input.id });

}

// A change to a space's notes is a commit owed: `src/sync.ts` listens here

// (and actions call `edited`) so the two never import each other.

let onEdit: (id: number) => void = () => {};

export const whenEdited = (listen: (id: number) => void): void => {

  onEdit = listen;

};

export const edited = (id: number): void => onEdit(id);