@lightupai/polaris 0.0.42 → 0.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightupai/polaris",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "type": "module",
   "bin": {
     "polaris": "bin/polaris",

package/src/service/db.ts

@@ -194,6 +194,17 @@ export async function listUsers(sql: Sql, orgId: string): Promise<User[]> {
   return rows.map((r) => ({ ...r, created_at: r.created_at.toISOString() }) as User);
 }
 
+export async function getRecentSignups(sql: Sql, since: Date, limit = 10): Promise<Array<User & { org_name: string }>> {
+  const rows = await sql`
+    SELECT u.*, o.name as org_name
+    FROM users u JOIN orgs o ON u.org_id = o.id
+    WHERE u.created_at >= ${since.toISOString()}
+    ORDER BY u.created_at DESC
+    LIMIT ${limit}
+  `;
+  return rows.map((r) => ({ ...r, created_at: r.created_at.toISOString(), org_name: r.org_name }) as User & { org_name: string });
+}
+
 // --- Projects (org-scoped) ---
 
 export async function createProject(sql: Sql, orgId: string, name: string): Promise<Project> {

package/src/web/app.ts

@@ -14,6 +14,7 @@ import {
   listSessions,
   getSessionPromptCounts,
   getProjectEvents,
+  getRecentSignups,
   type Sql,
 } from "../service/db";
 import { layout, nav } from "./layout";
@@ -52,6 +53,33 @@ function notifySignup(opts: { name: string; email: string; domain: string; orgNa
   }).catch(() => {});
 }
 
+function startSignupRollup(sql: Sql): void {
+  const HOUR = 60 * 60 * 1000;
+
+  async function postRollup(): Promise<void> {
+    const botToken = process.env.SIGNUP_SLACK_BOT_TOKEN;
+    if (!botToken) return;
+
+    const since = new Date(Date.now() - HOUR);
+    const signups = await getRecentSignups(sql, since, 10);
+    if (signups.length === 0) return;
+
+    const lines = signups.map((s) => `• *${s.name}* (${s.email}) — ${s.org_name}`);
+    const text = `:chart_with_upwards_trend: *${signups.length} signup${signups.length === 1 ? "" : "s"} in the last hour*\n${lines.join("\n")}`;
+
+    fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${botToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ channel: SIGNUP_CHANNEL, text }),
+    }).catch(() => {});
+  }
+
+  setInterval(postRollup, HOUR);
+}
+
 // --- Google OAuth ---
 
 function getGoogle(): Google {
@@ -88,6 +116,9 @@ setInterval(() => {
 export function createApp(sql: Sql) {
   const app = new Hono();
 
+  // Start hourly signup rollup
+  startSignupRollup(sql);
+
   // --- Landing page ---
 
   app.get("/", (c) => {

package/tests/signup-notifications.test.ts

@@ -0,0 +1,286 @@
+import { describe, expect, test, beforeAll, afterAll, beforeEach } from "bun:test";
+import { createDb, createOrg, createUser, getRecentSignups, type Sql } from "../src/service/db";
+import { resetTestData } from "./helpers";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris_test";
+
+let sql: Sql;
+
+// Capture outgoing Slack API calls
+const slackCalls: Array<{ url: string; body: Record<string, unknown> }> = [];
+const originalFetch = globalThis.fetch;
+
+beforeAll(async () => {
+  sql = await createDb(DATABASE_URL);
+
+  // Intercept fetch to capture Slack API calls
+  globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+
+    if (url.startsWith("https://slack.com/api/")) {
+      const body = JSON.parse(init?.body as string);
+      slackCalls.push({ url, body });
+      return new Response(JSON.stringify({ ok: true }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    return originalFetch(input, init);
+  };
+});
+
+afterAll(async () => {
+  globalThis.fetch = originalFetch;
+  await sql.end();
+});
+
+beforeEach(async () => {
+  await resetTestData(sql);
+  slackCalls.length = 0;
+});
+
+// --- getRecentSignups ---
+
+describe("getRecentSignups", () => {
+  test("returns users created within the time window", async () => {
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    await createUser(sql, "u1", "alice@acme.com", "Alice", "org1", "user:alice");
+    await createUser(sql, "u2", "bob@acme.com", "Bob", "org1", "user:bob");
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+
+    expect(signups).toHaveLength(2);
+    expect(signups[0].org_name).toBe("Acme");
+    expect(signups.map((s) => s.name).sort()).toEqual(["Alice", "Bob"]);
+  });
+
+  test("excludes users created before the time window", async () => {
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    await createUser(sql, "u1", "old@acme.com", "Old User", "org1", "user:old");
+    await sql`UPDATE users SET created_at = now() - interval '2 hours' WHERE id = 'u1'`;
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+
+    expect(signups).toHaveLength(0);
+  });
+
+  test("respects limit parameter", async () => {
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    for (let i = 0; i < 5; i++) {
+      await createUser(sql, `u${i}`, `user${i}@acme.com`, `User ${i}`, "org1", `user:user${i}`);
+    }
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 3);
+
+    expect(signups).toHaveLength(3);
+  });
+
+  test("returns most recent first", async () => {
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    await createUser(sql, "u1", "first@acme.com", "First", "org1", "user:first");
+    await sql`UPDATE users SET created_at = now() - interval '10 seconds' WHERE id = 'u1'`;
+    await createUser(sql, "u2", "second@acme.com", "Second", "org1", "user:second");
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+
+    expect(signups[0].name).toBe("Second");
+    expect(signups[1].name).toBe("First");
+  });
+
+  test("joins org name correctly across multiple orgs", async () => {
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    await createOrg(sql, "org2", "Startup", "startup.io");
+    await createUser(sql, "u1", "alice@acme.com", "Alice", "org1", "user:alice");
+    await createUser(sql, "u2", "bob@startup.io", "Bob", "org2", "user:bob");
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+
+    const alice = signups.find((s) => s.name === "Alice");
+    const bob = signups.find((s) => s.name === "Bob");
+    expect(alice?.org_name).toBe("Acme");
+    expect(bob?.org_name).toBe("Startup");
+  });
+});
+
+// --- notifySignup (imported indirectly via the app module) ---
+// We test the notification by importing and calling it directly.
+
+// Since notifySignup is a private function in app.ts, we test the
+// observable behavior: when the web app processes a signup, the right
+// Slack calls are made. We simulate this by importing the notification
+// logic as a standalone function.
+
+// Extract the notification logic for direct testing:
+function notifySignup(opts: { name: string; email: string; domain: string; orgName: string; isNewOrg: boolean }): void {
+  const botToken = process.env.SIGNUP_SLACK_BOT_TOKEN;
+  if (!botToken) return;
+
+  const emoji = opts.isNewOrg ? ":tada:" : ":wave:";
+  const action = opts.isNewOrg ? "signed up (new org)" : "joined";
+  const text = `${emoji} *${opts.name}* (${opts.email}) ${action} — ${opts.orgName} (${opts.domain})`;
+
+  fetch("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${botToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ channel: "#alerts-mql-stream", text }),
+  }).catch(() => {});
+}
+
+describe("notifySignup — new org", () => {
+  test("posts to #alerts-mql-stream with new org emoji and details", async () => {
+    process.env.SIGNUP_SLACK_BOT_TOKEN = "xoxb-test-token";
+
+    notifySignup({ name: "Alice Smith", email: "alice@newco.com", domain: "newco.com", orgName: "Newco", isNewOrg: true });
+
+    // Wait for the async fetch to resolve
+    await new Promise((r) => setTimeout(r, 50));
+
+    const call = slackCalls.find((c) => c.body.text?.toString().includes("Alice Smith"));
+    expect(call).toBeDefined();
+    expect(call!.body.channel).toBe("#alerts-mql-stream");
+    expect(call!.body.text).toContain(":tada:");
+    expect(call!.body.text).toContain("signed up (new org)");
+    expect(call!.body.text).toContain("alice@newco.com");
+    expect(call!.body.text).toContain("Newco");
+    expect(call!.body.text).toContain("newco.com");
+  });
+});
+
+describe("notifySignup — join existing org", () => {
+  test("posts to #alerts-mql-stream with join emoji", async () => {
+    process.env.SIGNUP_SLACK_BOT_TOKEN = "xoxb-test-token";
+
+    notifySignup({ name: "Bob Jones", email: "bob@acme.com", domain: "acme.com", orgName: "Acme", isNewOrg: false });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const call = slackCalls.find((c) => c.body.text?.toString().includes("Bob Jones"));
+    expect(call).toBeDefined();
+    expect(call!.body.channel).toBe("#alerts-mql-stream");
+    expect(call!.body.text).toContain(":wave:");
+    expect(call!.body.text).toContain("joined");
+    expect(call!.body.text).not.toContain("signed up");
+  });
+});
+
+describe("notifySignup — no token", () => {
+  test("does not post when SIGNUP_SLACK_BOT_TOKEN is not set", async () => {
+    delete process.env.SIGNUP_SLACK_BOT_TOKEN;
+
+    notifySignup({ name: "Ghost User", email: "ghost@nowhere.com", domain: "nowhere.com", orgName: "Nowhere", isNewOrg: true });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const call = slackCalls.find((c) => c.body.text?.toString().includes("Ghost User"));
+    expect(call).toBeUndefined();
+  });
+});
+
+describe("notifySignup — Slack API uses correct auth header", () => {
+  test("sends Bearer token in Authorization header", async () => {
+    process.env.SIGNUP_SLACK_BOT_TOKEN = "xoxb-my-secret-token";
+
+    // Override fetch to also capture headers
+    const capturedHeaders: Record<string, string>[] = [];
+    const prevFetch = globalThis.fetch;
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === "string" ? input : input.toString();
+      if (url.startsWith("https://slack.com/api/")) {
+        const headers: Record<string, string> = {};
+        if (init?.headers) {
+          const h = init.headers as Record<string, string>;
+          for (const [k, v] of Object.entries(h)) headers[k] = v;
+        }
+        capturedHeaders.push(headers);
+        return new Response(JSON.stringify({ ok: true }), {
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+      return prevFetch(input, init);
+    };
+
+    notifySignup({ name: "Test", email: "test@test.com", domain: "test.com", orgName: "Test", isNewOrg: true });
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(capturedHeaders.length).toBeGreaterThan(0);
+    expect(capturedHeaders[0].Authorization).toBe("Bearer xoxb-my-secret-token");
+
+    globalThis.fetch = prevFetch;
+  });
+});
+
+// --- Rollup ---
+
+describe("signup rollup message format", () => {
+  test("builds correct rollup from recent signups", async () => {
+    process.env.SIGNUP_SLACK_BOT_TOKEN = "xoxb-test-token";
+
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    await createOrg(sql, "org2", "Startup", "startup.io");
+    await createUser(sql, "u1", "alice@acme.com", "Alice Smith", "org1", "user:alice");
+    await createUser(sql, "u2", "bob@startup.io", "Bob Jones", "org2", "user:bob");
+    await createUser(sql, "u3", "carol@acme.com", "Carol Lee", "org1", "user:carol");
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+
+    expect(signups).toHaveLength(3);
+
+    // Simulate building the rollup message (same logic as in app.ts)
+    const lines = signups.map((s) => `• *${s.name}* (${s.email}) — ${s.org_name}`);
+    const text = `:chart_with_upwards_trend: *${signups.length} signup${signups.length === 1 ? "" : "s"} in the last hour*\n${lines.join("\n")}`;
+
+    expect(text).toContain("3 signups in the last hour");
+    expect(text).toContain("Alice Smith");
+    expect(text).toContain("Bob Jones");
+    expect(text).toContain("Carol Lee");
+    expect(text).toContain("Acme");
+    expect(text).toContain("Startup");
+
+    // Now actually post via the same Slack API path
+    fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${process.env.SIGNUP_SLACK_BOT_TOKEN}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ channel: "#alerts-mql-stream", text }),
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const rollupCall = slackCalls.find((c) => c.body.text?.toString().includes("signups in the last hour"));
+    expect(rollupCall).toBeDefined();
+    expect(rollupCall!.body.channel).toBe("#alerts-mql-stream");
+  });
+
+  test("singular form for single signup", async () => {
+    await createOrg(sql, "org1", "Acme", "acme.com");
+    await createUser(sql, "u1", "solo@acme.com", "Solo User", "org1", "user:solo");
+
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+    const text = `:chart_with_upwards_trend: *${signups.length} signup${signups.length === 1 ? "" : "s"} in the last hour*`;
+
+    expect(text).toContain("1 signup in the last hour");
+    expect(text).not.toContain("signups");
+  });
+
+  test("empty rollup produces no Slack call", async () => {
+    const since = new Date(Date.now() - 60 * 60 * 1000);
+    const signups = await getRecentSignups(sql, since, 10);
+
+    expect(signups).toHaveLength(0);
+    // In the real code, empty signups = early return, no Slack call
+    // Verify no calls were made
+    expect(slackCalls).toHaveLength(0);
+  });
+});