nixamp 0.15.0 → 0.16.0

package/dist/layouts.js

@@ -0,0 +1,353 @@
+import { randomUUID } from "node:crypto";
+export const PANEL_REGIONS = ["primary", "secondary", "sidebar", "drawer", "bottom", "overlay"];
+export const LAYOUT_SCOPES = ["system", "brand", "role", "user", "event"];
+export class LayoutError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+export const PANEL_REGISTRY = [
+    { type: "event-header", title: "Event" },
+    { type: "player", title: "Listen" },
+    { type: "host", title: "Host" },
+    { type: "about", title: "About" },
+    { type: "join", title: "Join" },
+    { type: "stage", title: "Stage", permissions: ["room.speak"] },
+    { type: "chat", title: "Chat" },
+    { type: "participants", title: "People", permissions: ["room.listen"] },
+    { type: "speakers", title: "Speakers", permissions: ["room.speak"] },
+    { type: "hand-raises", title: "Hand Raises", permissions: ["event.moderate"] },
+    { type: "raise-hand", title: "Raise Hand", permissions: ["room.raise_hand"] },
+    { type: "questions", title: "Questions" },
+    { type: "invite", title: "Invite", permissions: ["event.invite"] },
+    { type: "share", title: "Share" },
+    { type: "schedule", title: "Schedule", permissions: ["event.update"] },
+    { type: "event-controls", title: "Event Controls", permissions: ["event.start"] },
+    { type: "recording", title: "Recording", permissions: ["recording.start"] },
+    { type: "resources", title: "Resources" },
+    { type: "replay", title: "Replay" },
+    { type: "moderation", title: "Moderation", permissions: ["event.moderate"] },
+    { type: "diagnostics", title: "Diagnostics", permissions: ["admin.diagnostics"] },
+    { type: "network-health", title: "Network Health", permissions: ["admin.network"] },
+    { type: "advanced-nixamp", title: "Advanced NixAmp", permissions: ["admin.network"] },
+];
+const knownPanels = new Set(PANEL_REGISTRY.map((panel) => panel.type));
+function presetPanel(id, type, region, order, options = {}) {
+    const now = new Date(0).toISOString();
+    const definition = PANEL_REGISTRY.find((panel) => panel.type === type);
+    return {
+        id,
+        type,
+        visible: options.visible ?? true,
+        enabled: options.enabled ?? true,
+        region,
+        order,
+        ...(options.collapsed !== undefined ? { collapsed: options.collapsed } : {}),
+        ...(options.permissions ?? definition?.permissions
+            ? { permissions: options.permissions ?? definition?.permissions }
+            : {}),
+        config: options.config ?? {},
+        version: 1,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function preset(name, panels) {
+    const now = new Date(0).toISOString();
+    return {
+        id: name,
+        name,
+        scope: name === "nixamp-admin" ? "role" : "brand",
+        scopeId: name === "nixamp-admin" ? "admin" : "backtoschool",
+        panels,
+        version: 1,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+const viewerPanels = [
+    presetPanel("event-header", "event-header", "primary", 0),
+    presetPanel("player", "player", "primary", 1),
+    presetPanel("host", "host", "secondary", 2),
+    presetPanel("about", "about", "secondary", 3),
+    presetPanel("join", "join", "bottom", 4),
+    presetPanel("chat", "chat", "drawer", 5, { collapsed: true }),
+    presetPanel("questions", "questions", "drawer", 6, { collapsed: true }),
+    presetPanel("resources", "resources", "drawer", 7, { collapsed: true }),
+];
+const memberPanels = [
+    presetPanel("event-header", "event-header", "primary", 0),
+    presetPanel("player", "player", "primary", 1),
+    presetPanel("host", "host", "secondary", 2),
+    presetPanel("chat", "chat", "secondary", 3),
+    presetPanel("questions", "questions", "secondary", 4),
+    presetPanel("participants", "participants", "sidebar", 5),
+    presetPanel("invite", "invite", "sidebar", 6),
+    presetPanel("raise-hand", "raise-hand", "bottom", 7),
+    presetPanel("resources", "resources", "bottom", 8),
+];
+const hostPanels = [
+    presetPanel("event-header", "event-header", "primary", 0),
+    presetPanel("stage", "stage", "primary", 1),
+    presetPanel("speakers", "speakers", "secondary", 2),
+    presetPanel("participants", "participants", "secondary", 3),
+    presetPanel("invite", "invite", "sidebar", 4),
+    presetPanel("chat", "chat", "sidebar", 5),
+    presetPanel("hand-raises", "hand-raises", "sidebar", 6),
+    presetPanel("questions", "questions", "sidebar", 7),
+    presetPanel("event-controls", "event-controls", "bottom", 8),
+    presetPanel("schedule", "schedule", "bottom", 9),
+    presetPanel("recording", "recording", "bottom", 10),
+    presetPanel("share", "share", "bottom", 11),
+];
+const adminPanels = [
+    ...hostPanels.map((panel) => ({ ...panel })),
+    presetPanel("moderation", "moderation", "sidebar", 20),
+    presetPanel("diagnostics", "diagnostics", "sidebar", 21),
+    presetPanel("network-health", "network-health", "sidebar", 22),
+    presetPanel("advanced-nixamp", "advanced-nixamp", "drawer", 23),
+];
+export const LAYOUT_PRESETS = {
+    "backtoschool-viewer": preset("backtoschool-viewer", viewerPanels),
+    "backtoschool-member": preset("backtoschool-member", memberPanels),
+    "backtoschool-host": preset("backtoschool-host", hostPanels),
+    "nixamp-admin": preset("nixamp-admin", adminPanels),
+};
+const LAYOUT_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS nixamp_layouts (
+    id          TEXT PRIMARY KEY,
+    name        TEXT NOT NULL UNIQUE,
+    scope       TEXT NOT NULL,
+    scope_id    TEXT,
+    owner_id    TEXT,
+    panels      JSONB NOT NULL DEFAULT '[]'::jsonb,
+    version     INTEGER NOT NULL DEFAULT 1,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    CHECK (scope IN ('system', 'brand', 'role', 'user', 'event'))
+  );
+  CREATE INDEX IF NOT EXISTS nixamp_layouts_resolution
+    ON nixamp_layouts (scope, scope_id, updated_at DESC);
+
+  CREATE TABLE IF NOT EXISTS nixamp_layout_history (
+    id              BIGSERIAL PRIMARY KEY,
+    layout_id       TEXT NOT NULL,
+    version         INTEGER NOT NULL,
+    panels          JSONB NOT NULL,
+    changed_by      TEXT,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+  );
+  CREATE INDEX IF NOT EXISTS nixamp_layout_history_layout
+    ON nixamp_layout_history (layout_id, version DESC);
+`;
+function string(value, name, limit, required = false) {
+    if (value === undefined || value === null) {
+        if (required)
+            throw new LayoutError(`${name} is required`, 422);
+        return "";
+    }
+    if (typeof value !== "string")
+        throw new LayoutError(`${name} must be text`, 422);
+    const result = value.replace(/[\u0000-\u001f\u007f]/g, " ").trim();
+    if (required && !result)
+        throw new LayoutError(`${name} is required`, 422);
+    if (result.length > limit)
+        throw new LayoutError(`${name} is too long`, 422);
+    return result;
+}
+function when(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value === "string")
+        return new Date(value).toISOString();
+    return new Date(0).toISOString();
+}
+function object(value, name) {
+    if (value === undefined)
+        return {};
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new LayoutError(`${name} must be an object`, 422);
+    }
+    return value;
+}
+export function panelFrom(value, position = 0) {
+    const input = object(value, "panel");
+    const id = string(input["id"] ?? randomUUID(), "panel id", 100, true);
+    const type = string(input["type"], "panel type", 100, true);
+    const region = string(input["region"] ?? "primary", "panel region", 20, true);
+    if (!PANEL_REGIONS.includes(region))
+        throw new LayoutError("panel region is invalid", 422);
+    const order = input["order"] === undefined ? position : Number(input["order"]);
+    if (!Number.isInteger(order) || order < 0)
+        throw new LayoutError("panel order must be a non-negative integer", 422);
+    const permissions = input["permissions"];
+    if (permissions !== undefined && (!Array.isArray(permissions) || permissions.some((item) => typeof item !== "string"))) {
+        throw new LayoutError("panel permissions must be text", 422);
+    }
+    const version = input["version"] === undefined ? 1 : Number(input["version"]);
+    if (!Number.isInteger(version) || version < 1)
+        throw new LayoutError("panel version must be a positive integer", 422);
+    const createdAt = typeof input["createdAt"] === "string" ? input["createdAt"] : new Date().toISOString();
+    const updatedAt = typeof input["updatedAt"] === "string" ? input["updatedAt"] : createdAt;
+    return {
+        id,
+        type,
+        ...(input["title"] !== undefined ? { title: string(input["title"], "panel title", 100) } : {}),
+        visible: input["visible"] === undefined ? true : Boolean(input["visible"]),
+        enabled: input["enabled"] === undefined ? true : Boolean(input["enabled"]),
+        region: region,
+        order,
+        ...(input["size"] !== undefined ? { size: object(input["size"], "panel size") } : {}),
+        ...(input["collapsed"] !== undefined ? { collapsed: Boolean(input["collapsed"]) } : {}),
+        ...(permissions !== undefined ? { permissions: permissions } : {}),
+        config: object(input["config"], "panel config"),
+        version,
+        createdAt,
+        updatedAt,
+    };
+}
+function panelsFrom(value) {
+    const parsed = typeof value === "string" ? JSON.parse(value) : value;
+    if (!Array.isArray(parsed))
+        throw new LayoutError("panels must be a list", 422);
+    const ids = new Set();
+    return parsed.map((panel, index) => {
+        const result = panelFrom(panel, index);
+        if (ids.has(result.id))
+            throw new LayoutError(`panel id ${result.id} is duplicated`, 422);
+        ids.add(result.id);
+        return result;
+    }).sort((a, b) => a.order - b.order);
+}
+function layoutFrom(row) {
+    return {
+        id: String(row["id"] ?? ""),
+        name: String(row["name"] ?? ""),
+        scope: String(row["scope"] ?? "user"),
+        ...(row["scope_id"] ? { scopeId: String(row["scope_id"]) } : {}),
+        ...(row["owner_id"] ? { ownerId: String(row["owner_id"]) } : {}),
+        panels: panelsFrom(row["panels"] ?? []),
+        version: Number(row["version"] ?? 1),
+        createdAt: when(row["created_at"]),
+        updatedAt: when(row["updated_at"]),
+    };
+}
+export function presetLayout(name) {
+    const found = LAYOUT_PRESETS[name];
+    return found ? structuredClone(found) : null;
+}
+export function resolveLayout(layers, permissions) {
+    const resolved = new Map();
+    for (const layout of layers) {
+        for (const panel of layout.panels)
+            resolved.set(panel.id, structuredClone(panel));
+    }
+    return [...resolved.values()]
+        .filter((panel) => knownPanels.has(panel.type) && panel.enabled && panel.visible)
+        .filter((panel) => (panel.permissions ?? []).every((permission) => permissions.has(permission)))
+        .sort((a, b) => a.order - b.order);
+}
+export class Layouts {
+    db;
+    ready = null;
+    constructor(db) {
+        this.db = db;
+    }
+    async ensure() {
+        this.ready ??= this.db.query(LAYOUT_SCHEMA).then(() => undefined);
+        await this.ready;
+    }
+    async get(reference) {
+        const builtIn = presetLayout(reference);
+        if (builtIn)
+            return builtIn;
+        await this.ensure();
+        const { rows } = await this.db.query("SELECT * FROM nixamp_layouts WHERE id = $1 OR name = $1 LIMIT 1", [reference]);
+        return rows[0] ? layoutFrom(rows[0]) : null;
+    }
+    async scoped(scope, scopeId) {
+        await this.ensure();
+        const { rows } = await this.db.query("SELECT * FROM nixamp_layouts WHERE scope = $1 AND scope_id = $2 ORDER BY updated_at", [scope, scopeId]);
+        return rows.map(layoutFrom);
+    }
+    async create(input, ownerId) {
+        const name = string(input.name, "layout name", 100, true);
+        const scope = string(input.scope, "layout scope", 20, true);
+        if (!LAYOUT_SCOPES.includes(scope))
+            throw new LayoutError("layout scope is invalid", 422);
+        if ((scope === "user" || scope === "event") && !ownerId)
+            throw new LayoutError("sign in to create this layout", 401);
+        const panels = panelsFrom(input.panels ?? []);
+        await this.ensure();
+        const { rows } = await this.db.query(`INSERT INTO nixamp_layouts (id, name, scope, scope_id, owner_id, panels)
+       VALUES ($1, $2, $3, NULLIF($4, ''), NULLIF($5, ''), $6::jsonb)
+       RETURNING *`, [randomUUID(), name, scope, string(input.scopeId, "scopeId", 160), ownerId, JSON.stringify(panels)]);
+        const row = rows[0];
+        if (!row)
+            throw new LayoutError("could not create the layout", 500);
+        return layoutFrom(row);
+    }
+    async update(reference, panels, version, accountId) {
+        const current = await this.get(reference);
+        if (!current)
+            throw new LayoutError("layout not found", 404);
+        if (!current.ownerId || current.ownerId !== accountId) {
+            throw new LayoutError("only the layout owner can change it", 403);
+        }
+        if (!Number.isInteger(version) || Number(version) < 1)
+            throw new LayoutError("version is required", 428);
+        if (Number(version) !== current.version)
+            throw new LayoutError("the layout changed; reload it and try again", 409);
+        const nextPanels = panelsFrom(panels);
+        await this.ensure();
+        const { rows } = await this.db.query(`WITH previous AS (
+         SELECT id, version, panels FROM nixamp_layouts
+         WHERE (id = $1 OR name = $1) AND owner_id = $2 AND version = $3
+       ), remembered AS (
+         INSERT INTO nixamp_layout_history (layout_id, version, panels, changed_by)
+         SELECT id, version, panels, $2 FROM previous
+       )
+       UPDATE nixamp_layouts SET panels = $4::jsonb, version = version + 1, updated_at = now()
+       WHERE id IN (SELECT id FROM previous)
+       RETURNING *`, [reference, accountId, current.version, JSON.stringify(nextPanels)]);
+        const row = rows[0];
+        if (!row)
+            throw new LayoutError("the layout changed; reload it and try again", 409);
+        return layoutFrom(row);
+    }
+    async addPanel(reference, panel, version, accountId) {
+        const current = await this.get(reference);
+        if (!current)
+            throw new LayoutError("layout not found", 404);
+        return this.update(reference, [...current.panels, panelFrom(panel, current.panels.length)], version, accountId);
+    }
+    async updatePanel(reference, panelId, patch, version, accountId) {
+        const current = await this.get(reference);
+        if (!current)
+            throw new LayoutError("layout not found", 404);
+        const at = current.panels.findIndex((panel) => panel.id === panelId);
+        if (at < 0)
+            throw new LayoutError("panel not found", 404);
+        const changes = object(patch, "panel");
+        const previous = current.panels[at];
+        const updated = panelFrom({ ...previous, ...changes, id: previous.id, version: previous.version + 1 }, at);
+        const panels = current.panels.with(at, updated);
+        return this.update(reference, panels, version, accountId);
+    }
+    async removePanel(reference, panelId, version, accountId) {
+        const current = await this.get(reference);
+        if (!current)
+            throw new LayoutError("layout not found", 404);
+        if (!current.panels.some((panel) => panel.id === panelId))
+            throw new LayoutError("panel not found", 404);
+        return this.update(reference, current.panels.filter((panel) => panel.id !== panelId), version, accountId);
+    }
+    async reset(reference, presetName, version, accountId) {
+        const defaults = presetLayout(presetName);
+        if (!defaults)
+            throw new LayoutError("layout preset not found", 404);
+        return this.update(reference, defaults.panels, version, accountId);
+    }
+}

package/dist/live-api.d.ts

@@ -0,0 +1,20 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type Accounts } from "./accounts.ts";
+import { type LiveEvents } from "./live-events.ts";
+import { type Layouts } from "./layouts.ts";
+import { type Rooms } from "./rooms.ts";
+export interface LiveApiOptions {
+    events: LiveEvents;
+    accounts?: Accounts;
+    layouts?: Layouts;
+    rooms?: Rooms;
+    site?: string;
+    email?: (to: string, note: {
+        title: string;
+        body: string;
+        url: string;
+    }) => Promise<boolean>;
+}
+export declare function handleLiveApi(request: IncomingMessage, response: ServerResponse, url: URL, options: LiveApiOptions): Promise<boolean>;
+export declare function liveApiPath(path: string): boolean;
+export declare function invitationState(value: unknown): string | null;