@pylonsync/create-pylon 0.19.0 → 0.20.0

package/templates/waitlist/functions/seedDemo.ts

@@ -0,0 +1,32 @@
+import { mutation } from "@pylonsync/functions";
+import { demoDataEnabled, demoSignups } from "../lib/demo";
+import { syncWaitlistStat } from "../lib/stats";
+
+// seedDemo — fill an empty waitlist with fictional signups in development.
+//
+// The landing page counter calls this when it finds no signups, and the
+// dashboard calls it once on load. It writes nothing unless demo data is on
+// (lib/demo.ts: PYLON_DEMO_DATA, else a `pylon dev` process), so `pylon start`,
+// Docker, and Pylon Cloud deploys do not get demo rows. It also writes nothing
+// once any Signup exists, so it cannot mix demo rows into a real list. Clearing
+// every signup in development seeds the list again on the next load. The
+// advisory lock stops two first visits from seeding twice.
+//
+// Public because the first visitor in `pylon dev` is anonymous. It returns only
+// a flag, never a row.
+export default mutation<Record<string, never>, { seeded: boolean }>({
+  auth: "public",
+  async handler(ctx) {
+    if (!demoDataEnabled(ctx.env)) return { seeded: false };
+
+    await ctx.db.advisoryLock("waitlist_seed_demo");
+    const existing = await ctx.db.unsafe.list("Signup");
+    if (existing.length > 0) return { seeded: false };
+
+    for (const row of demoSignups(Date.now())) {
+      await ctx.db.unsafe.insert("Signup", { email: row.email, createdAt: row.createdAt });
+    }
+    await syncWaitlistStat(ctx.db.unsafe);
+    return { seeded: true };
+  },
+});

package/templates/waitlist/lib/demo.ts

@@ -0,0 +1,94 @@
+// Demo signups for local development.
+//
+// `pylon dev` fills an empty waitlist with about 180 fictional signups spread
+// over the last 30 days, so the counter, chart, and list have data. A deploy
+// does not seed: `demoDataEnabled` is true only when PYLON_DEMO_DATA is on, or
+// when it is unset and the process runs under `pylon dev`. Set
+// PYLON_DEMO_DATA=0 to turn it off in development too.
+//
+// Pure data + pure shaping, so functions/seedDemo.ts stays a thin wrapper and
+// this file is testable without a server.
+
+const ON = new Set(["1", "true", "yes", "on"]);
+const OFF = new Set(["0", "false", "no", "off"]);
+
+/**
+ * True when demo rows may be written. An explicit PYLON_DEMO_DATA wins.
+ * Otherwise it needs both PYLON_DEV_MODE on and PYLON_DEV_WATCH_DIR set. Only
+ * `pylon dev` sets PYLON_DEV_WATCH_DIR; `pylon start` and the Docker image do
+ * not, and the image turns PYLON_DEV_MODE on by default, so dev mode alone is
+ * not proof of a local machine.
+ */
+export function demoDataEnabled(env: Record<string, string | undefined>): boolean {
+  const explicit = env.PYLON_DEMO_DATA?.trim().toLowerCase();
+  if (explicit && ON.has(explicit)) return true;
+  if (explicit && OFF.has(explicit)) return false;
+  const dev = env.PYLON_DEV_MODE?.trim().toLowerCase();
+  const devMode = dev === "1" || dev === "true";
+  return devMode && Boolean(env.PYLON_DEV_WATCH_DIR?.trim());
+}
+
+const FIRST = [
+  "priya", "marcus", "lena", "tomas", "aisha", "ben", "hana", "diego", "sofia", "kwame",
+  "ingrid", "raj", "noor", "felix", "maya", "owen", "yuki", "carmen", "theo", "amara",
+  "jonas", "leila", "sam", "ines", "dev", "clara", "malik", "rosa", "ethan", "zara",
+];
+const LAST = [
+  "nair", "bell", "fischer", "alvarez", "khan", "osei", "sato", "ruiz", "marin", "mensah",
+  "berg", "patel", "haddad", "wagner", "chen", "reilly", "tanaka", "vega", "park", "okafor",
+];
+// Fictional company domains on the reserved .example TLD, so no demo address
+// can reach a real inbox.
+const DOMAINS = [
+  "fieldnote.example", "northwind.example", "quarry.example", "bluefin.example", "wren.example",
+  "copperline.example", "tidewater.example", "larkspur.example", "kestrel.example", "orchardlabs.example",
+  "sable.example", "ironwood.example", "halcyon.example", "pinecrest.example", "vantage.example",
+];
+
+/** Small deterministic PRNG (mulberry32) so the demo set is stable per seed. */
+function rng(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export interface DemoSignup {
+  email: string;
+  createdAt: string;
+}
+
+/**
+ * About 180 signups over the 30 days before `nowMs`, rising toward today.
+ * Emails are unique. Every timestamp is in the past.
+ */
+export function demoSignups(nowMs: number, seed = 7): DemoSignup[] {
+  const rand = rng(seed);
+  const out: DemoSignup[] = [];
+  const seen = new Set<string>();
+  const DAY = 86_400_000;
+  for (let daysAgo = 29; daysAgo >= 0; daysAgo--) {
+    // Growth curve: ~2/day a month ago, ~10/day this week, plus noise.
+    const base = 2 + Math.round((29 - daysAgo) * 0.28);
+    const count = Math.max(0, base + Math.round((rand() - 0.5) * 4));
+    for (let i = 0; i < count; i++) {
+      const first = FIRST[Math.floor(rand() * FIRST.length)];
+      const last = LAST[Math.floor(rand() * LAST.length)];
+      const domain = DOMAINS[Math.floor(rand() * DOMAINS.length)];
+      const shape = rand();
+      const local = shape < 0.5 ? `${first}.${last}` : shape < 0.8 ? `${first}` : `${first[0]}${last}`;
+      const email = `${local}@${domain}`;
+      if (seen.has(email)) continue;
+      seen.add(email);
+      // A random minute inside that day, never later than `nowMs`.
+      const offset = Math.floor(rand() * DAY);
+      const ts = Math.min(nowMs - 60_000, nowMs - daysAgo * DAY - offset);
+      out.push({ email, createdAt: new Date(ts).toISOString() });
+    }
+  }
+  return out.sort((a, b) => (a.createdAt < b.createdAt ? -1 : 1));
+}

package/templates/waitlist/lib/launch.ts

@@ -0,0 +1,19 @@
+// The launch line under the hero form, from `siteConfig.hero.launchDate`.
+//
+// Before the date it names the month ("Public launch: March 2027"). From the
+// date on it says invites are going out, so the page never shows a launch date
+// that has already passed. The date is read and formatted in UTC, so the
+// server render and the browser produce the same text.
+
+/** `launchDate` is "YYYY-MM-DD" (UTC). Returns null for a malformed date. */
+export function launchLabel(launchDate: string, nowMs: number): string | null {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(launchDate.trim());
+  if (!m) return null;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  const atMs = Date.UTC(y, mo - 1, d);
+  const at = new Date(atMs);
+  if (at.getUTCFullYear() !== y || at.getUTCMonth() !== mo - 1 || at.getUTCDate() !== d) return null;
+  if (nowMs >= atMs) return "Invites are going out now";
+  const month = at.toLocaleDateString("en-US", { month: "long", year: "numeric", timeZone: "UTC" });
+  return `Public launch: ${month}`;
+}

package/templates/waitlist/lib/site.config.ts

@@ -36,7 +36,9 @@ export type MockRow = { title: string; tag: string; done?: boolean };
 
 export type WaitlistConfig = BaseConfig & {
   hero: {
-    launchNote: string; // one short line, set in mono: when it ships
+    // "YYYY-MM-DD" (UTC). The page shows the month until this date, then
+    // "Invites are going out now". See lib/launch.ts.
+    launchDate: string;
     headline: string;
     subcopy: string;
     emailPlaceholder: string;
@@ -47,9 +49,11 @@ export type WaitlistConfig = BaseConfig & {
   counter: {
     enabled: boolean;
     label: string; // e.g. "people on the list"
-    // A vanity baseline added to the real, live signup count so a brand-new
-    // page doesn't read "0". Set to 0 to show only genuine signups.
-    seedCount?: number;
+    labelOne: string; // the same label for a count of 1, e.g. "person on the list"
+    // Signups collected before this site existed (an old form, a spreadsheet),
+    // added to the Signup table's count. Keep 0 unless those people are real;
+    // the page shows the sum as one number.
+    importedCount: number;
   };
   // The HTML/CSS product window on the right of the hero. No screenshot.
   mock: {
@@ -93,11 +97,11 @@ export const siteConfig: WaitlistConfig = {
   seo: {
     title: "Lumo — projects, notes, and tasks in one workspace. Coming soon.",
     description:
-      "Lumo puts your projects, notes, and tasks in one workspace. It launches this fall. Join the waitlist for an early invite.",
+      "Lumo puts your projects, notes, and tasks in one workspace. Join the waitlist for an early invite.",
   },
 
   hero: {
-    launchNote: "Launch: fall 2026",
+    launchDate: "2027-03-02",
     headline: "Projects, notes, and tasks in one workspace.",
     subcopy:
       "Lumo is one app for the plan, the notes behind it, and the tasks that come out of it. Join the list and we send an invite before the public launch.",
@@ -110,7 +114,8 @@ export const siteConfig: WaitlistConfig = {
   counter: {
     enabled: true,
     label: "people on the list",
-    seedCount: 1200,
+    labelOne: "person on the list",
+    importedCount: 0,
   },
 
   mock: {
@@ -148,8 +153,8 @@ export const siteConfig: WaitlistConfig = {
     headline: "Questions",
     items: [
       {
-        q: "When does Lumo launch?",
-        a: "Fall 2026. People on the waitlist get an invite before the public launch.",
+        q: "Who gets invited first?",
+        a: "People get invites in the order they joined. Each invite covers one workspace for up to five people.",
       },
       {
         q: "What do I get for joining?",

package/templates/waitlist/lib/stats.ts

@@ -28,3 +28,38 @@ export interface WaitlistStatsData {
 export type WaitlistStatsResult =
   | ({ authorized: true } & WaitlistStatsData)
   | { authorized: false };
+
+/* ------------------------- public live counter ------------------------- */
+
+// The public counter shows the Signup table's row count, read from the
+// PII-free WaitlistStat row. `importedCount` is `siteConfig.counter.importedCount`:
+// signups collected before this site existed (an old form, a spreadsheet). It is
+// 0 by default, so the page shows only rows in the table.
+export function publicCount(
+  statRows: ReadonlyArray<{ count: number }>,
+  importedCount = 0,
+): number {
+  const real = statRows.length > 0 ? Math.max(0, Math.floor(statRows[0].count)) : 0;
+  const imported = Number.isFinite(importedCount) ? Math.max(0, Math.floor(importedCount)) : 0;
+  return real + imported;
+}
+
+// The subset of `ctx.db.unsafe` the recount needs. Typed structurally so the
+// helper runs against the real handle and a test double.
+export interface StatDb {
+  list(entity: string): Promise<unknown[]>;
+  insert(entity: string, data: Record<string, unknown>): Promise<unknown>;
+  update(entity: string, id: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+// Write the Signup row count into the single WaitlistStat row, creating it if
+// missing. Every writer of Signup calls this in the same transaction, so the
+// public number is always the table's count.
+export async function syncWaitlistStat(db: StatDb): Promise<number> {
+  const total = (await db.list("Signup")).length;
+  const stat = (await db.list("WaitlistStat"))[0] as { id: string } | undefined;
+  const now = new Date().toISOString();
+  if (stat) await db.update("WaitlistStat", stat.id, { count: total, updatedAt: now });
+  else await db.insert("WaitlistStat", { count: total, updatedAt: now });
+  return total;
+}

package/templates/waitlist/tests/counter.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import { publicCount, syncWaitlistStat, type StatDb } from "../lib/stats";
+import { demoDataEnabled, demoSignups } from "../lib/demo";
+import { launchLabel } from "../lib/launch";
+import { siteConfig } from "../lib/site.config";
+
+describe("publicCount", () => {
+  test("is the table's count when nothing is imported", () => {
+    expect(publicCount([{ count: 3 }])).toBe(3);
+    expect(publicCount([])).toBe(0);
+  });
+  test("adds only an explicit, non-negative imported count", () => {
+    expect(publicCount([{ count: 3 }], 40)).toBe(43);
+    expect(publicCount([{ count: 3 }], -5)).toBe(3);
+    expect(publicCount([{ count: 3 }], Number.NaN)).toBe(3);
+  });
+  test("the shipped config adds nothing to the real count", () => {
+    expect(siteConfig.counter.importedCount).toBe(0);
+  });
+});
+
+// An in-memory stand-in for ctx.db.unsafe.
+function fakeDb(signups: number): StatDb & { rows: Record<string, Record<string, unknown>[]> } {
+  const rows: Record<string, Record<string, unknown>[]> = {
+    Signup: Array.from({ length: signups }, (_, i) => ({ id: `s${i}` })),
+    WaitlistStat: [],
+  };
+  return {
+    rows,
+    async list(entity) {
+      return rows[entity] ?? [];
+    },
+    async insert(entity, data) {
+      const id = `${entity}-${rows[entity].length}`;
+      rows[entity].push({ id, ...data });
+      return id;
+    },
+    async update(entity, id, data) {
+      const row = rows[entity].find((r) => r.id === id);
+      if (row) Object.assign(row, data);
+      return id;
+    },
+  };
+}
+
+describe("syncWaitlistStat", () => {
+  test("creates the stat row with the Signup count", async () => {
+    const db = fakeDb(5);
+    expect(await syncWaitlistStat(db)).toBe(5);
+    expect(db.rows.WaitlistStat).toHaveLength(1);
+    expect(db.rows.WaitlistStat[0].count).toBe(5);
+  });
+  test("recounts into the existing row instead of adding one", async () => {
+    const db = fakeDb(5);
+    await syncWaitlistStat(db);
+    db.rows.Signup.push({ id: "late" });
+    await syncWaitlistStat(db);
+    expect(db.rows.WaitlistStat).toHaveLength(1);
+    expect(db.rows.WaitlistStat[0].count).toBe(6);
+  });
+});
+
+describe("demoDataEnabled", () => {
+  test("needs a `pylon dev` process when PYLON_DEMO_DATA is unset", () => {
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "1", PYLON_DEV_WATCH_DIR: "/src/app" })).toBe(true);
+    // The Docker base image turns dev mode on by default; without `pylon dev` it must not seed.
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "true" })).toBe(false);
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "true", PYLON_DEV_WATCH_DIR: "/src/app" })).toBe(true);
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "false" })).toBe(false);
+    expect(demoDataEnabled({})).toBe(false);
+  });
+  test("an explicit PYLON_DEMO_DATA wins", () => {
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "1", PYLON_DEV_WATCH_DIR: "/src/app", PYLON_DEMO_DATA: "0" })).toBe(false);
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "false", PYLON_DEMO_DATA: "1" })).toBe(true);
+  });
+});
+
+describe("demoSignups", () => {
+  const now = Date.parse("2026-09-26T15:00:00Z");
+  const rows = demoSignups(now);
+  test("unique emails, all in the past 30 days", () => {
+    expect(new Set(rows.map((r) => r.email)).size).toBe(rows.length);
+    for (const r of rows) {
+      const t = Date.parse(r.createdAt);
+      expect(t).toBeLessThan(now);
+      expect(t).toBeGreaterThan(now - 31 * 86_400_000);
+    }
+  });
+  test("enough rows to fill the chart, stable for a seed", () => {
+    expect(rows.length).toBeGreaterThan(120);
+    expect(demoSignups(now)).toEqual(rows);
+  });
+});
+
+describe("launchLabel", () => {
+  const now = Date.parse("2026-09-26T12:00:00Z");
+  test("names the month before the date", () => {
+    expect(launchLabel("2027-03-02", now)).toBe("Public launch: March 2027");
+  });
+  test("never shows a date that has passed", () => {
+    expect(launchLabel("2026-09-01", now)).toBe("Invites are going out now");
+  });
+  test("rejects a malformed date", () => {
+    expect(launchLabel("fall 2026", now)).toBeNull();
+    expect(launchLabel("2026-02-31", now)).toBeNull();
+  });
+});

package/templates/waitlist/tests/live-count.test.tsx

@@ -0,0 +1,48 @@
+import { afterEach, expect, mock, test } from "bun:test";
+import React from "react";
+import { cleanup, render, screen } from "@testing-library/react";
+
+// The live count reads the WaitlistStat row. Mock the data boundary so the test
+// controls what the "server" says.
+let statRows: { id: string; count: number; updatedAt: string }[] = [];
+let loading = false;
+mock.module("@pylonsync/react", () => ({
+  db: { useQuery: () => ({ data: statRows, loading }) },
+  callFn: async () => ({ seeded: false }),
+}));
+mock.module("@pylonsync/client", () => ({
+  EnsureGuest: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+}));
+const { LiveCount } = await import("../app/(marketing)/waitlist-hero");
+
+afterEach(() => {
+  cleanup();
+  statRows = [];
+  loading = false;
+});
+
+test("shows the table's count, with no vanity baseline", () => {
+  statRows = [{ id: "w", count: 42, updatedAt: "" }];
+  render(<LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />);
+  expect(screen.getByTestId("live-count").textContent).toBe("42");
+});
+
+test("shows nothing, not a placeholder number, before the first sync", () => {
+  loading = true;
+  render(<LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />);
+  expect(screen.queryByTestId("live-count")).toBeNull();
+});
+
+test("uses the singular label for one signup", () => {
+  statRows = [{ id: "w", count: 1, updatedAt: "" }];
+  const { container } = render(
+    <LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />,
+  );
+  expect(container.textContent).toContain("1person on the list");
+});
+
+test("shows nothing while the list is empty", () => {
+  statRows = [{ id: "w", count: 0, updatedAt: "" }];
+  render(<LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />);
+  expect(screen.queryByTestId("live-count")).toBeNull();
+});

package/templates/ai-chat/tests/example.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from "bun:test";
-
-// Your first test. Run the suite with:  pylon test  (or: npm test)
-//
-// `pylon test` discovers every *.test.ts file under tests/ (or functions/) and
-// runs it with Bun's test runner against an in-memory Pylon. Replace this
-// placeholder with tests for your functions and helpers — see AGENTS.md →
-// Testing for the pure-logic and HTTP-against-`pylon dev` patterns.
-
-test("placeholder — replace me with a real test", () => {
-  expect(true).toBe(true);
-});

package/templates/backend/consumer/apps/api/functions/feed.ts

@@ -1,57 +0,0 @@
-import { query } from "@pylonsync/functions";
-
-/**
- * Public feed — every Post, newest first. Joins author Profile + the
- * caller's like state into the response so the client can render a
- * row without N+1 follow-up queries.
- *
- * For a real consumer app, paginate this (limit + cursor by createdAt)
- * — the scaffold returns at most 100 rows, which is plenty for a
- * Hello-World feed but unsustainable past a few thousand posts.
- */
-export default query({
-	args: {},
-	async handler(ctx) {
-		const posts = (await ctx.db.query("Post", {})) as any[];
-		const sorted = [...posts]
-			.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
-			.slice(0, 100);
-
-		const callerProfile = ctx.auth.userId
-			? ((await ctx.db.query("Profile", {
-					userId: ctx.auth.userId,
-				})) as any[])[0]
-			: null;
-
-		const out: Array<{
-			id: string;
-			body: string;
-			createdAt: string;
-			author: { id: string; handle: string; displayName: string } | null;
-			likeCount: number;
-			likedByMe: boolean;
-		}> = [];
-		for (const p of sorted) {
-			const author = (await ctx.db.get("Profile", p.authorId)) as any;
-			const likes = (await ctx.db.query("Like", { postId: p.id })) as any[];
-			const likedByMe = callerProfile
-				? likes.some((l) => l.profileId === callerProfile.id)
-				: false;
-			out.push({
-				id: p.id,
-				body: p.body,
-				createdAt: p.createdAt,
-				author: author
-					? {
-							id: author.id,
-							handle: author.handle,
-							displayName: author.displayName,
-						}
-					: null,
-				likeCount: likes.length,
-				likedByMe,
-			});
-		}
-		return out;
-	},
-});

package/templates/backend/consumer/apps/api/functions/profilePosts.ts

@@ -1,17 +0,0 @@
-import { query, v } from "@pylonsync/functions";
-
-/**
- * Every Post by a single Profile, newest first. Used by the profile
- * page on each platform.
- */
-export default query({
-	args: { profileId: v.id("Profile") },
-	async handler(ctx, args: { profileId: string }) {
-		const rows = (await ctx.db.query("Post", {
-			authorId: args.profileId,
-		})) as any[];
-		return rows.sort(
-			(a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt),
-		);
-	},
-});

package/templates/backend/consumer/apps/api/functions/toggleLike.ts

@@ -1,48 +0,0 @@
-import { mutation, v } from "@pylonsync/functions";
-
-/**
- * Toggle a like on a Post. Idempotent — calling twice from the same
- * user lands at the original state. Returns { liked: boolean,
- * likeCount: number } so the client can update its UI without a
- * follow-up read.
- */
-export default mutation({
-	args: { postId: v.id("Post") },
-	async handler(ctx, args: { postId: string }) {
-		if (!ctx.auth.userId) {
-			throw ctx.error("UNAUTHENTICATED", "log in first");
-		}
-		const profiles = (await ctx.db.query("Profile", {
-			userId: ctx.auth.userId,
-		})) as any[];
-		if (profiles.length === 0) {
-			throw ctx.error("NO_PROFILE", "create a profile first");
-		}
-		const profile = profiles[0];
-
-		const existing = (await ctx.db.query("Like", {
-			postId: args.postId,
-			profileId: profile.id,
-		})) as any[];
-
-		if (existing.length === 0) {
-			await ctx.db.insert("Like", {
-				postId: args.postId,
-				profileId: profile.id,
-				createdAt: new Date().toISOString(),
-			});
-		} else {
-			for (const like of existing) {
-				await ctx.db.delete("Like", like.id);
-			}
-		}
-
-		const allLikes = (await ctx.db.query("Like", {
-			postId: args.postId,
-		})) as any[];
-		return {
-			liked: existing.length === 0,
-			likeCount: allLikes.length,
-		};
-	},
-});