create-m5kdev 0.25.3 → 0.26.2

package/templates/minimal-app/apps/server/drizzle/meta/_journal.json.tpl

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1783931793066,
+      "tag": "0000_wealthy_absorbing_man",
+      "breakpoints": true
+    }
+  ]
+}

package/templates/minimal-app/apps/server/drizzle/reset.ts.tpl

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/** Deletes the local SQLite database (and stored-email output) for a clean slate. */
+function sqlitePathFromDatabaseUrl(url: string) {
+  if (!url.startsWith("file:")) return null;
+  return path.resolve(process.cwd(), url.slice("file:".length));
+}
+
+async function removeIfExists(target: string) {
+  await fs.rm(target, { recursive: true, force: true });
+}
+
+async function reset() {
+  const dbPath = sqlitePathFromDatabaseUrl(process.env.DATABASE_URL ?? "");
+  if (dbPath) {
+    await removeIfExists(dbPath);
+    await removeIfExists(`${dbPath}-shm`);
+    await removeIfExists(`${dbPath}-wal`);
+    await fs.mkdir(path.dirname(dbPath), { recursive: true });
+  }
+
+  const emailDirectory = process.env.EMAIL_OUTPUT_DIRECTORY
+    ? path.resolve(process.cwd(), process.env.EMAIL_OUTPUT_DIRECTORY)
+    : null;
+
+  if (emailDirectory) {
+    await removeIfExists(emailDirectory);
+    await fs.mkdir(emailDirectory, { recursive: true });
+  }
+}
+
+void reset();

package/templates/minimal-app/apps/server/drizzle/seed.e2e.ts.tpl

@@ -0,0 +1,244 @@
+/**
+ * E2E fixture seed — used only by the e2e package's prepare scripts, never by
+ * generated apps (the CLI excludes this file). The user-facing demo seed lives
+ * in ./seed.ts.
+ */
+import { hashPassword } from "better-auth/crypto";
+import { eq } from "drizzle-orm";
+import { v4 as uuidv4 } from "uuid";
+import { orm, schema } from "./db";
+
+const profile = process.env.AUTH_E2E_PROFILE ?? "standard";
+const ADMIN_EMAIL = `admin.${profile}@auth-e2e.local`;
+const ADMIN_PASSWORD = "password1234";
+
+function slugify(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+async function ensureUser({
+  id,
+  name,
+  email,
+  password,
+  role = "user",
+  emailVerified = true,
+}: {
+  id: string;
+  name: string;
+  email: string;
+  password?: string;
+  role?: string;
+  emailVerified?: boolean;
+}) {
+  const [existingUser] = await orm
+    .select()
+    .from(schema.users)
+    .where(eq(schema.users.email, email))
+    .limit(1);
+  if (existingUser) return existingUser;
+
+  const [user] = await orm
+    .insert(schema.users)
+    .values({
+      id,
+      name,
+      email,
+      emailVerified,
+      role,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    })
+    .returning();
+
+  if (!user) throw new Error(`Failed to seed user ${email}`);
+
+  if (password) {
+    await orm.insert(schema.accounts).values({
+      id: uuidv4(),
+      accountId: user.id,
+      providerId: "credential",
+      userId: user.id,
+      password: await hashPassword(password),
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  return user;
+}
+
+async function ensureOrganization(userId: string) {
+  const organizationId = `auth-e2e-enterprise-${profile}`;
+  const teamId = `auth-e2e-team-${profile}`;
+
+  const [existingOrganization] = await orm
+    .select()
+    .from(schema.organizations)
+    .where(eq(schema.organizations.id, organizationId))
+    .limit(1);
+
+  if (!existingOrganization) {
+    await orm.insert(schema.organizations).values({
+      id: organizationId,
+      name: `Auth E2E Enterprise ${profile}`,
+      slug: `auth-e2e-enterprise-${profile}`,
+      type: "enterprise",
+      createdAt: new Date(),
+    });
+  }
+
+  const [existingMember] = await orm
+    .select()
+    .from(schema.members)
+    .where(eq(schema.members.userId, userId))
+    .limit(1);
+
+  if (!existingMember) {
+    await orm.insert(schema.members).values({
+      id: uuidv4(),
+      organizationId,
+      userId,
+      role: "owner",
+      createdAt: new Date(),
+    });
+  }
+
+  const [existingTeam] = await orm
+    .select()
+    .from(schema.teams)
+    .where(eq(schema.teams.id, teamId))
+    .limit(1);
+
+  if (!existingTeam) {
+    await orm.insert(schema.teams).values({
+      id: teamId,
+      name: "Editorial",
+      organizationId,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  const [existingTeamMember] = await orm
+    .select()
+    .from(schema.teamMembers)
+    .where(eq(schema.teamMembers.userId, userId))
+    .limit(1);
+
+  if (!existingTeamMember) {
+    await orm.insert(schema.teamMembers).values({
+      id: uuidv4(),
+      teamId,
+      userId,
+      role: "owner",
+      createdAt: new Date(),
+    });
+  }
+
+  return { organizationId, teamId };
+}
+
+async function seedPosts(userId: string, organizationId: string) {
+  const existingPosts = await orm.select().from(schema.posts).limit(1);
+  if (existingPosts.length > 0) return;
+
+  const posts = [
+    {
+      title: "A small blog that protects auth changes",
+      excerpt: "The first fixture post explains why the E2E app exists.",
+      content:
+        "This post is intentionally simple. It gives Playwright a protected application surface after authentication succeeds.",
+    },
+    {
+      title: "Organization invites should never be guessed",
+      excerpt: "Invite links are generated by Better Auth and captured by stored email previews.",
+      content:
+        "The E2E suite verifies that organization invitation emails contain the correct app URL and can be accepted by a new user.",
+    },
+  ];
+
+  await orm.insert(schema.posts).values(
+    posts.map((post, index) => ({
+      id: uuidv4(),
+      ...post,
+      slug: `${slugify(post.title)}-${profile}-${index}`,
+      authorUserId: userId,
+      organizationId,
+      createdAt: new Date(Date.now() - index * 60_000),
+    }))
+  );
+}
+
+async function seedExpiredWaitlistCode() {
+  const [existing] = await orm
+    .select()
+    .from(schema.waitlist)
+    .where(eq(schema.waitlist.code, "expired-waitlist-code"))
+    .limit(1);
+  if (existing) return;
+
+  await orm.insert(schema.waitlist).values({
+    id: uuidv4(),
+    email: `expired.${profile}@auth-e2e.local`,
+    name: "Expired Invite",
+    type: "WAITLIST",
+    status: "INVITED",
+    code: "expired-waitlist-code",
+    expiresAt: new Date(Date.now() - 60_000),
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+}
+
+async function seedProvisionedClaimUser() {
+  const user = await ensureUser({
+    id: `auth-e2e-claim-user-${profile}`,
+    name: "Provisioned Claim User",
+    email: `claim.${profile}@provisioned.auth-e2e.local`,
+    role: "user",
+    emailVerified: false,
+  });
+
+  const [existingClaim] = await orm
+    .select()
+    .from(schema.waitlist)
+    .where(eq(schema.waitlist.claimUserId, user.id))
+    .limit(1);
+  if (existingClaim) return user;
+
+  await orm.insert(schema.waitlist).values({
+    id: `auth-e2e-claim-${profile}`,
+    type: "ACCOUNT_CLAIM",
+    status: "INVITED",
+    claimUserId: user.id,
+    code: uuidv4(),
+    expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 14),
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+
+  return user;
+}
+
+async function seed() {
+  const admin = await ensureUser({
+    id: `auth-e2e-admin-${profile}`,
+    name: "Auth E2E Admin",
+    email: ADMIN_EMAIL,
+    password: ADMIN_PASSWORD,
+    role: "admin",
+  });
+  const { organizationId } = await ensureOrganization(admin.id);
+  await seedPosts(admin.id, organizationId);
+  await seedExpiredWaitlistCode();
+  await seedProvisionedClaimUser();
+
+  console.info(`Seeded ${profile}. Admin login: ${ADMIN_EMAIL} / ${ADMIN_PASSWORD}`);
+}
+
+void seed();

package/templates/minimal-app/apps/server/drizzle/seed.ts.tpl

@@ -1,180 +1,181 @@
-import { hashPassword } from "better-auth/crypto";
-import { eq } from "drizzle-orm";
-import { v4 as uuidv4 } from "uuid";
-import { orm, schema } from "../src/db";
-import { syncDatabase } from "./sync";
-
-const DEMO_EMAIL = "admin@{{APP_SLUG}}.local";
-const DEMO_PASSWORD = "password1234";
-const ORGANIZATION_ID = "{{APP_SLUG}}-org";
-const TEAM_ID = "{{APP_SLUG}}-team";
-
-async function ensureDemoUser() {
-  const [existingUser] = await orm
-    .select()
-    .from(schema.users)
-    .where(eq(schema.users.email, DEMO_EMAIL))
-    .limit(1);
-
-  if (existingUser) {
-    return existingUser;
-  }
-
-  const userId = uuidv4();
-  const [user] = await orm
-    .insert(schema.users)
-    .values({
-      id: userId,
-      name: "Demo Editor",
-      email: DEMO_EMAIL,
-      emailVerified: true,
-      role: "admin",
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    })
-    .returning();
-
-  if (!user) {
-    throw new Error("Failed to create demo user.");
-  }
-
-  await orm.insert(schema.accounts).values({
-    id: uuidv4(),
-    accountId: user.id,
-    providerId: "credential",
-    userId: user.id,
-    password: await hashPassword(DEMO_PASSWORD),
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  });
-
-  return user;
-}
-
-async function ensureOrganization(userId: string) {
-  const [existingOrganization] = await orm
-    .select()
-    .from(schema.organizations)
-    .where(eq(schema.organizations.id, ORGANIZATION_ID))
-    .limit(1);
-
-  if (!existingOrganization) {
-    await orm.insert(schema.organizations).values({
-      id: ORGANIZATION_ID,
-      name: "{{APP_NAME}}",
-      slug: "{{APP_SLUG}}",
-      type: "enterprise",
-      createdAt: new Date(),
-    });
-  }
-
-  const [existingMember] = await orm
-    .select()
-    .from(schema.members)
-    .where(eq(schema.members.userId, userId))
-    .limit(1);
-
-  if (!existingMember) {
-    await orm.insert(schema.members).values({
-      id: uuidv4(),
-      organizationId: ORGANIZATION_ID,
-      userId,
-      role: "owner",
-      createdAt: new Date(),
-    });
-  }
-
-  const [existingTeam] = await orm
-    .select()
-    .from(schema.teams)
-    .where(eq(schema.teams.id, TEAM_ID))
-    .limit(1);
-
-  if (!existingTeam) {
-    await orm.insert(schema.teams).values({
-      id: TEAM_ID,
-      name: "Editorial",
-      organizationId: ORGANIZATION_ID,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    });
-  }
-
-  const [existingTeamMember] = await orm
-    .select()
-    .from(schema.teamMembers)
-    .where(eq(schema.teamMembers.userId, userId))
-    .limit(1);
-
-  if (!existingTeamMember) {
-    await orm.insert(schema.teamMembers).values({
-      id: uuidv4(),
-      teamId: TEAM_ID,
-      userId,
-      role: "owner",
-      createdAt: new Date(),
-    });
-  }
-
-  return { organizationId: ORGANIZATION_ID, teamId: TEAM_ID };
-}
-
-async function seedPosts(userId: string, organizationId: string | null, teamId: string | null) {
-  const existingPosts = await orm.select().from(schema.posts).limit(1);
-  if (existingPosts.length > 0) {
-    return;
-  }
-
-  await orm.insert(schema.posts).values([
-    {
-      authorUserId: userId,
-      organizationId,
-      teamId,
-      title: "An editorial workflow you can ship in an afternoon",
-      slug: "editorial-workflow-in-an-afternoon",
-      excerpt: "A first draft on how this minimal starter is wired together.",
-      content:
-        "This starter keeps the moving parts visible. Shared contracts live in the shared app, business rules stay in services, and the web layer only does composition and UI work.",
-      status: "published",
-      publishedAt: new Date(),
-      createdAt: new Date(Date.now() - 1000 * 60 * 60 * 24 * 5),
-    },
-    {
-      authorUserId: userId,
-      organizationId,
-      teamId,
-      title: "Three habits that keep CRUD apps from drifting into chaos",
-      slug: "three-habits-that-keep-crud{{PACKAGE_SCOPE}}s-focused",
-      excerpt: "A draft about explicit composition, typed contracts, and URL state.",
-      content:
-        "Keep your composition explicit, keep your schemas honest, and keep the URL involved in user intent. Those three choices do most of the architectural work in a small product.",
-      status: "draft",
-      createdAt: new Date(Date.now() - 1000 * 60 * 60 * 24 * 2),
-    },
-    {
-      authorUserId: userId,
-      organizationId,
-      teamId,
-      title: "What a minimal platform starter should still refuse to compromise on",
-      slug: "minimal-platform-starter-non-negotiables",
-      excerpt: "A published note on keeping the foundation opinionated without being heavy.",
-      content:
-        "Even a minimal starter should include auth, structured modules, and a coherent app shell. Cutting those corners only moves the complexity into the first week of work.",
-      status: "published",
-      publishedAt: new Date(Date.now() - 1000 * 60 * 60 * 16),
-      createdAt: new Date(Date.now() - 1000 * 60 * 60 * 18),
-    },
-  ]);
-}
-
-async function seed() {
-  await syncDatabase();
-  const user = await ensureDemoUser();
-  const { organizationId, teamId } = await ensureOrganization(user.id);
-
-  await seedPosts(user.id, organizationId, teamId);
-
-  console.info(`Seed completed. Demo login: ${DEMO_EMAIL} / ${DEMO_PASSWORD}`);
-}
-
-void seed();
+import { hashPassword } from "better-auth/crypto";
+import { eq } from "drizzle-orm";
+import { v4 as uuidv4 } from "uuid";
+import { isRemote, orm, schema } from "./db";
+
+const DEMO_EMAIL = "admin{{PACKAGE_SCOPE}}.local";
+const DEMO_PASSWORD = "password1234";
+const ORGANIZATION_ID = "{{APP_SLUG}}-org";
+const TEAM_ID = "{{APP_SLUG}}-team";
+
+async function ensureDemoUser() {
+  const [existingUser] = await orm
+    .select()
+    .from(schema.users)
+    .where(eq(schema.users.email, DEMO_EMAIL))
+    .limit(1);
+
+  if (existingUser) {
+    return existingUser;
+  }
+
+  const userId = uuidv4();
+  const [user] = await orm
+    .insert(schema.users)
+    .values({
+      id: userId,
+      name: "Demo Editor",
+      email: DEMO_EMAIL,
+      emailVerified: true,
+      role: "admin",
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    })
+    .returning();
+
+  if (!user) {
+    throw new Error("Failed to create demo user.");
+  }
+
+  await orm.insert(schema.accounts).values({
+    id: uuidv4(),
+    accountId: user.id,
+    providerId: "credential",
+    userId: user.id,
+    password: await hashPassword(DEMO_PASSWORD),
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+
+  return user;
+}
+
+async function ensureOrganization(userId: string) {
+  const [existingOrganization] = await orm
+    .select()
+    .from(schema.organizations)
+    .where(eq(schema.organizations.id, ORGANIZATION_ID))
+    .limit(1);
+
+  if (!existingOrganization) {
+    await orm.insert(schema.organizations).values({
+      id: ORGANIZATION_ID,
+      name: "{{APP_NAME}}",
+      slug: "{{APP_SLUG}}",
+      type: "enterprise",
+      createdAt: new Date(),
+    });
+  }
+
+  const [existingMember] = await orm
+    .select()
+    .from(schema.members)
+    .where(eq(schema.members.userId, userId))
+    .limit(1);
+
+  if (!existingMember) {
+    await orm.insert(schema.members).values({
+      id: uuidv4(),
+      organizationId: ORGANIZATION_ID,
+      userId,
+      role: "owner",
+      createdAt: new Date(),
+    });
+  }
+
+  const [existingTeam] = await orm
+    .select()
+    .from(schema.teams)
+    .where(eq(schema.teams.id, TEAM_ID))
+    .limit(1);
+
+  if (!existingTeam) {
+    await orm.insert(schema.teams).values({
+      id: TEAM_ID,
+      name: "Editorial",
+      organizationId: ORGANIZATION_ID,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  const [existingTeamMember] = await orm
+    .select()
+    .from(schema.teamMembers)
+    .where(eq(schema.teamMembers.userId, userId))
+    .limit(1);
+
+  if (!existingTeamMember) {
+    await orm.insert(schema.teamMembers).values({
+      id: uuidv4(),
+      teamId: TEAM_ID,
+      userId,
+      role: "owner",
+      createdAt: new Date(),
+    });
+  }
+
+  return { organizationId: ORGANIZATION_ID, teamId: TEAM_ID };
+}
+
+async function seedPosts(userId: string, organizationId: string | null, teamId: string | null) {
+  const existingPosts = await orm.select().from(schema.posts).limit(1);
+  if (existingPosts.length > 0) {
+    return;
+  }
+
+  await orm.insert(schema.posts).values([
+    {
+      authorUserId: userId,
+      organizationId,
+      teamId,
+      title: "An editorial workflow you can ship in an afternoon",
+      slug: "editorial-workflow-in-an-afternoon",
+      excerpt: "A first draft on how this minimal starter is wired together.",
+      content:
+        "This starter keeps the moving parts visible. Shared contracts live in the shared app, business rules stay in services, and the web layer only does composition and UI work.",
+      status: "published",
+      publishedAt: new Date(),
+      createdAt: new Date(Date.now() - 1000 * 60 * 60 * 24 * 5),
+    },
+    {
+      authorUserId: userId,
+      organizationId,
+      teamId,
+      title: "Three habits that keep CRUD apps from drifting into chaos",
+      slug: "three-habits-that-keep-crud{{PACKAGE_SCOPE}}s-focused",
+      excerpt: "A draft about explicit composition, typed contracts, and URL state.",
+      content:
+        "Keep your composition explicit, keep your schemas honest, and keep the URL involved in user intent. Those three choices do most of the architectural work in a small product.",
+      status: "draft",
+      createdAt: new Date(Date.now() - 1000 * 60 * 60 * 24 * 2),
+    },
+    {
+      authorUserId: userId,
+      organizationId,
+      teamId,
+      title: "What a minimal platform starter should still refuse to compromise on",
+      slug: "minimal-platform-starter-non-negotiables",
+      excerpt: "A published note on keeping the foundation opinionated without being heavy.",
+      content:
+        "Even a minimal starter should include auth, structured modules, and a coherent app shell. Cutting those corners only moves the complexity into the first week of work.",
+      status: "published",
+      publishedAt: new Date(Date.now() - 1000 * 60 * 60 * 16),
+      createdAt: new Date(Date.now() - 1000 * 60 * 60 * 18),
+    },
+  ]);
+}
+
+async function seed() {
+  if (isRemote) {
+    await orm.$client.sync();
+  }
+  const user = await ensureDemoUser();
+  const { organizationId, teamId } = await ensureOrganization(user.id);
+
+  await seedPosts(user.id, organizationId, teamId);
+
+  console.info(`Seed completed. Demo login: ${DEMO_EMAIL} / ${DEMO_PASSWORD}`);
+}
+
+void seed();