Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

7.3 KB
Raw Blame
import Sqlite from "better-sqlite3";
import { drizzle } from "drizzle-orm/better-sqlite3";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { createInvite, useInvite } from "../../src/db/queries/community/invite";

describe("community invite quota consumption", () => {
  let sqlite: Sqlite.Database;
  let db: ReturnType<typeof drizzle>;

  beforeEach(() => {
    sqlite = new Sqlite(":memory:");
    sqlite.exec(`
      CREATE TABLE user (
        id TEXT PRIMARY KEY,
        name TEXT NOT NULL,
        image TEXT,
        avatarVersion INTEGER NOT NULL DEFAULT 0,
        avatarObjectKey TEXT,
        discriminator TEXT NOT NULL DEFAULT '0000',
        isBot INTEGER NOT NULL DEFAULT 0,
        ownerUserId TEXT,
        deletedAt TEXT
      );
      CREATE TABLE community_server_invite (
        id TEXT PRIMARY KEY,
        server_id TEXT NOT NULL,
        created_by TEXT,
        token TEXT NOT NULL UNIQUE,
        max_uses INTEGER,
        uses INTEGER DEFAULT 0,
        expires_at TEXT,
        created_at TEXT NOT NULL
      );
      CREATE TABLE community_server_member (
        id TEXT PRIMARY KEY,
        server_id TEXT NOT NULL,
        user_id TEXT NOT NULL,
        role TEXT DEFAULT 'member',
        rail_order INTEGER DEFAULT 0,
        joined_at TEXT NOT NULL,
        UNIQUE(server_id, user_id)
      );
      CREATE TABLE community_funnel_analytics_event (
        id TEXT PRIMARY KEY NOT NULL,
        owner_user_id TEXT NOT NULL,
        event_name TEXT NOT NULL,
        conversation_type TEXT,
        source_id TEXT NOT NULL,
        dedupe_key TEXT NOT NULL UNIQUE,
        created_at TEXT NOT NULL,
        claimed_at TEXT
      );
    `);
    db = drizzle(sqlite);
    // better-sqlite3's Drizzle adapter has transactions but no D1-style batch.
    // Execute the generated statements in one native SQLite transaction so the
    // query's all-or-nothing quota contract is exercised against real SQL.
    (db as any).batch = (statements: Array<{ toSQL: () => { sql: string; params: unknown[] } }>) =>
      sqlite.transaction(() =>
        statements.map((statement) => {
          const query = statement.toSQL();
          const prepared = sqlite.prepare(query.sql);
          return prepared.reader
            ? prepared.all(...query.params)
            : prepared.run(...query.params);
        }),
      )();
    sqlite.prepare("INSERT INTO user (id, name, discriminator) VALUES (?, ?, ?)").run("u1", "One", "0001");
    sqlite.prepare("INSERT INTO user (id, name, discriminator) VALUES (?, ?, ?)").run("u2", "Two", "0002");
  });

  afterEach(() => sqlite.close());

  function seedInvite(maxUses: number | null = 1, createdBy: string | null = "owner") {
    sqlite.prepare(`
      INSERT INTO community_server_invite
        (id, server_id, created_by, token, max_uses, uses, created_at)
      VALUES ('iv1', 's1', ?, 'token1', ?, 0, '2026-01-01T00:00:00.000Z')
    `).run(createdBy, maxUses);
  }

  it("admits only one member for the final finite use", async () => {
    seedInvite(1);
    await expect(useInvite(db as never, "token1", "u1")).resolves.not.toBeNull();
    await expect(useInvite(db as never, "token1", "u2")).resolves.toBeNull();

    expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
      .toEqual({ uses: 1 });
    expect(sqlite.prepare("SELECT user_id FROM community_server_member ORDER BY user_id").all())
      .toEqual([{ user_id: "u1" }]);
  });

  it("preserves duplicate capacity and rolls back earlier writes after a late analytics failure", async () => {
    seedInvite(null);
    sqlite.prepare("INSERT INTO user (id, name, discriminator) VALUES (?, ?, ?)")
      .run("owner", "Owner", "0009");
    const first = await useInvite(db as never, "token1", "u1");
    expect(first).not.toBeNull();
    const beforeMembers = sqlite.prepare("SELECT * FROM community_server_member ORDER BY id").all();
    const beforeEvents = sqlite.prepare("SELECT * FROM community_funnel_analytics_event ORDER BY id").all();
    expect(beforeMembers).toHaveLength(1);
    expect(beforeMembers[0]).toMatchObject({ server_id: "s1", user_id: "u1", role: "member" });
    const memberId = (beforeMembers[0] as { id: string }).id;
    expect(first!.member.id).toBe(memberId);
    expect(beforeEvents).toHaveLength(1);
    expect(beforeEvents[0]).toMatchObject({
      owner_user_id: "owner", event_name: "invited_human_joined", source_id: memberId,
    });
    expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
      .toEqual({ uses: 1 });

    await expect(useInvite(db as never, "token1", "u1")).rejects.toThrow();
    expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
      .toEqual({ uses: 1 });
    expect(sqlite.prepare("SELECT * FROM community_server_member ORDER BY id").all()).toEqual(beforeMembers);
    expect(sqlite.prepare("SELECT * FROM community_funnel_analytics_event ORDER BY id").all()).toEqual(beforeEvents);

    sqlite.exec(`
      CREATE TRIGGER reject_late_invite_event
      BEFORE INSERT ON community_funnel_analytics_event
      WHEN NEW.event_name = 'invited_human_joined'
      BEGIN SELECT RAISE(ABORT, 'late analytics insertion rejected'); END;
    `);
    await expect(useInvite(db as never, "token1", "u2")).rejects.toThrow("late analytics insertion rejected");
    expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get())
      .toEqual({ uses: 1 });
    expect(sqlite.prepare("SELECT * FROM community_server_member ORDER BY id").all()).toEqual(beforeMembers);
    expect(sqlite.prepare("SELECT * FROM community_funnel_analytics_event ORDER BY id").all()).toEqual(beforeEvents);
  });

  it("admits a legacy invite without inventing a funnel owner", async () => {
    seedInvite(1, null);

    await expect(useInvite(db as never, "token1", "u1")).resolves.not.toBeNull();

    expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_funnel_analytics_event").get())
      .toEqual({ count: 0 });
  });

  it("does not consume capacity or create membership when the joining person is absent", async () => {
    seedInvite(1);
    await expect(useInvite(db as never, "token1", "missing")).resolves.toBeNull();
    expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get()).toEqual({ uses: 0 });
    expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_server_member").get()).toEqual({ count: 0 });
    expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_funnel_analytics_event").get()).toEqual({ count: 0 });
  });

  it("rejects an invalid complete identity before member or capacity writes", async () => {
    seedInvite(1);
    sqlite.prepare("UPDATE user SET discriminator='' WHERE id='u1'").run();
    await expect(useInvite(db as never, "token1", "u1")).rejects.toThrow();
    expect(sqlite.prepare("SELECT uses FROM community_server_invite WHERE id='iv1'").get()).toEqual({ uses: 0 });
    expect(sqlite.prepare("SELECT COUNT(*) AS count FROM community_server_member").get()).toEqual({ count: 0 });
  });

  it("enforces the active invite cap inside the insert statement", async () => {
    seedInvite(null);

    await expect(createInvite(db as never, {
      serverId: "s1",
      createdBy: "u1",
      maxActive: 1,
    })).resolves.toBeNull();

    expect(sqlite.prepare("SELECT count(*) AS count FROM community_server_invite WHERE server_id='s1'").get())
      .toEqual({ count: 1 });
  });
});