Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

9.0 KB
Raw Blame
import { UserCreateSchema, UserUpdateSchema, type InstanceUser } from "@edgeever/shared";
import { zValidator } from "@hono/zod-validator";
import type { Hono } from "hono";
import { auditStatement } from "./audit";
import type { AppContext, AppEnv, AuthContext } from "./api-context";
import { hashPassword } from "./auth-crypto";
import { isProtectedDemoAccount } from "./demo-mode";
import { createId, isoNow } from "./entity-utils";
import { badRequest, conflict, forbidden, notFound, unauthorized } from "./http-errors";
import { requireOwner } from "./request-auth";
import { mapResourceStorageSummary, type ResourceStatsRow } from "./resource-service";
import type { DatabaseAdapter } from "./storage-contract";
import { markWorkspaceExampleSeedPendingStatement } from "./workspace-example-seed";
import {
  createDefaultNotebookRows,
  markWorkspaceSeedLocalizationPendingStatement,
} from "./workspace-provisioning";

export type InstanceUserRow = {
  id: string;
  username: string;
  password_hash: string;
  display_name: string | null;
  is_disabled: number;
  last_login_at: string | null;
  created_at: string;
  role: "owner" | "member";
};

type UserRouteDependencies = {
  authenticateRequest: (context: AppContext, touch: boolean) => Promise<AuthContext | null>;
  getInstanceUser: (database: DatabaseAdapter, userId: string) => Promise<InstanceUserRow | null>;
};

export const mapInstanceUser = (row: InstanceUserRow): InstanceUser => ({
  id: row.id,
  username: row.username,
  displayName: row.display_name,
  role: row.role,
  isDisabled: Boolean(row.is_disabled),
  lastLoginAt: row.last_login_at,
  createdAt: row.created_at,
});

const requireOwnerRequest = async (
  context: AppContext,
  authenticateRequest: UserRouteDependencies["authenticateRequest"],
) => {
  const auth = await authenticateRequest(context, true);
  if (!auth) return unauthorized(context, "Authentication required.");
  context.set("auth", auth);
  return requireOwner(context);
};

export const registerUserRoutes = (
  app: Hono<AppEnv>,
  dependencies: UserRouteDependencies,
) => {
  app.get("/api/v1/instance/storage-usage", async (context) => {
    const denied = await requireOwnerRequest(context, dependencies.authenticateRequest);
    if (denied) return denied;

    const [stats, userStats] = await Promise.all([
      context.env.storage.db.prepare(
        `SELECT COUNT(*) AS total_count,
                COALESCE(SUM(r.byte_size), 0) AS total_bytes,
                COALESCE(SUM(CASE WHEN r.kind = 'image' THEN 1 ELSE 0 END), 0) AS image_count,
                COALESCE(SUM(CASE WHEN r.kind = 'attachment' THEN 1 ELSE 0 END), 0) AS attachment_count
         FROM resources r
         INNER JOIN memos m ON m.id = r.memo_id
         WHERE r.is_deleted = 0`,
      ).first<ResourceStatsRow>(),
      context.env.storage.db.prepare(
        `SELECT wm.user_id, COUNT(r.memo_id) AS total_count,
                COALESCE(SUM(r.byte_size), 0) AS total_bytes,
                COALESCE(SUM(CASE WHEN r.kind = 'image' THEN 1 ELSE 0 END), 0) AS image_count,
                COALESCE(SUM(CASE WHEN r.kind = 'attachment' THEN 1 ELSE 0 END), 0) AS attachment_count
         FROM workspace_members wm
         LEFT JOIN memos m ON m.workspace_id = wm.workspace_id
         LEFT JOIN resources r ON r.memo_id = m.id AND r.is_deleted = 0
         GROUP BY wm.user_id`,
      ).all<ResourceStatsRow & { user_id: string }>(),
    ]);

    return context.json({
      summary: mapResourceStorageSummary(stats),
      users: userStats.results.map((row) => ({
        userId: row.user_id,
        summary: mapResourceStorageSummary(row),
      })),
    });
  });

  app.get("/api/v1/users", async (context) => {
    const denied = await requireOwnerRequest(context, dependencies.authenticateRequest);
    if (denied) return denied;

    const rows = await context.env.storage.db.prepare(
      `SELECT u.id, u.username, u.password_hash, u.display_name, u.is_disabled,
              u.last_login_at, u.created_at, wm.role
       FROM users u
       INNER JOIN workspace_members wm ON wm.user_id = u.id
       ORDER BY wm.role = 'owner' DESC, u.created_at ASC`,
    ).all<InstanceUserRow>();

    return context.json({ users: rows.results.map(mapInstanceUser) });
  });

  app.post("/api/v1/users", zValidator("json", UserCreateSchema), async (context) => {
    const denied = await requireOwnerRequest(context, dependencies.authenticateRequest);
    if (denied) return denied;

    const input = context.req.valid("json");
    const existing = await context.env.storage.db.prepare(`SELECT id FROM users WHERE username = ?`)
      .bind(input.username)
      .first();
    if (existing) return conflict(context, "username_exists", "Username already exists.");

    const userId = createId("usr");
    const workspaceId = createId("ws");
    const now = isoNow();
    const passwordHash = await hashPassword(input.password);
    // The owner's language is not the member's. Notebooks start in the owner's
    // locale and, together with the default templates, are localized at the
    // member's first sign-in.
    const notebooks = createDefaultNotebookRows(workspaceId, context.req.header("accept-language"));
    const statements = [
      context.env.storage.db.prepare(
        `INSERT INTO users (id, username, password_hash, display_name, created_at, updated_at)
         VALUES (?, ?, ?, ?, ?, ?)`,
      ).bind(userId, input.username, passwordHash, input.displayName ?? input.username, now, now),
      context.env.storage.db.prepare(
        `INSERT INTO workspaces (id, name, is_personal, created_at, updated_at) VALUES (?, ?, 1, ?, ?)`,
      ).bind(workspaceId, `${input.displayName ?? input.username}'s workspace`, now, now),
      context.env.storage.db.prepare(
        `INSERT INTO workspace_members (workspace_id, user_id, role, created_at) VALUES (?, ?, 'member', ?)`,
      ).bind(workspaceId, userId, now),
      ...notebooks.map((notebook) => context.env.storage.db.prepare(
        `INSERT INTO notebooks (id, workspace_id, parent_id, name, slug, icon, color, sort_order, created_at, updated_at)
         VALUES (?, ?, NULL, ?, ?, 'notebook', ?, ?, ?, ?)`,
      ).bind(notebook.id, workspaceId, notebook.name, notebook.slug, notebook.color, notebook.sortOrder, now, now)),
      markWorkspaceSeedLocalizationPendingStatement(context.env.storage.db, workspaceId, now),
      markWorkspaceExampleSeedPendingStatement(context.env.storage.db, workspaceId, now),
      auditStatement(context.env.storage.db, "user", context.get("auth").actorId, "user.create", "user", userId, {
        username: input.username,
      }),
    ];
    await context.env.storage.db.batch(statements);

    const user = await dependencies.getInstanceUser(context.env.storage.db, userId);
    return context.json({ user: user ? mapInstanceUser(user) : null }, 201);
  });

  app.patch("/api/v1/users/:id", zValidator("json", UserUpdateSchema), async (context) => {
    const denied = await requireOwnerRequest(context, dependencies.authenticateRequest);
    if (denied) return denied;

    const userId = context.req.param("id");
    const input = context.req.valid("json");
    const current = await dependencies.getInstanceUser(context.env.storage.db, userId);
    if (!current) return notFound(context, "User not found");
    if (
      isProtectedDemoAccount(
        context.env.EDGE_EVER_DEMO_MODE,
        context.env.EDGE_EVER_AUTH_USERNAME,
        current.username,
      ) && (input.password !== undefined || input.isDisabled !== undefined)
    ) {
      return forbidden(context, "The demo owner account uses fixed credentials and cannot be modified.");
    }
    if (current.role === "owner" && input.isDisabled === true) {
      return badRequest(context, "The instance owner cannot be disabled.");
    }

    const updates: string[] = [];
    const binds: unknown[] = [];
    if (input.displayName !== undefined) {
      updates.push("display_name = ?");
      binds.push(input.displayName);
    }
    if (input.password !== undefined) {
      updates.push("password_hash = ?");
      binds.push(await hashPassword(input.password));
    }
    if (input.isDisabled !== undefined) {
      updates.push("is_disabled = ?");
      binds.push(input.isDisabled ? 1 : 0);
    }
    updates.push("updated_at = ?");
    binds.push(isoNow(), userId);

    const statements = [
      context.env.storage.db.prepare(`UPDATE users SET ${updates.join(", ")} WHERE id = ?`).bind(...binds),
      auditStatement(context.env.storage.db, "user", context.get("auth").actorId, "user.update", "user", userId, {
        passwordReset: input.password !== undefined,
        isDisabled: input.isDisabled,
      }),
    ];
    if (input.password !== undefined || input.isDisabled === true) {
      statements.push(
        context.env.storage.db.prepare(
          `UPDATE sessions SET revoked_at = ? WHERE user_id = ? AND revoked_at IS NULL`,
        ).bind(isoNow(), userId),
      );
    }
    await context.env.storage.db.batch(statements);

    const user = await dependencies.getInstanceUser(context.env.storage.db, userId);
    return context.json({ user: user ? mapInstanceUser(user) : null });
  });
};