create-skit 0.1.0

package/templates/blank/src/components/auth/email-auth-form.tsx

@@ -0,0 +1,109 @@
+"use client";
+
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+
+import { authClient } from "@/lib/auth-client";
+
+type EmailAuthFormProps = {
+  mode: "sign-in" | "sign-up";
+};
+
+export function EmailAuthForm({ mode }: EmailAuthFormProps) {
+  const isSignUp = mode === "sign-up";
+  const router = useRouter();
+  const [error, setError] = useState<string | null>(null);
+  const [isPending, setIsPending] = useState(false);
+
+  async function handleSubmit(formData: FormData) {
+    const email = String(formData.get("email") ?? "");
+    const password = String(formData.get("password") ?? "");
+    const name = String(formData.get("name") ?? "");
+
+    setIsPending(true);
+    setError(null);
+
+    try {
+      const result = isSignUp
+        ? await authClient.signUp.email({
+            email,
+            password,
+            name
+          })
+        : await authClient.signIn.email({
+            email,
+            password
+          });
+
+      if (result.error) {
+        setError(result.error.message ?? "Authentication failed.");
+        return;
+      }
+
+      router.push("/dashboard");
+      router.refresh();
+    } catch {
+      setError("Authentication failed.");
+    } finally {
+      setIsPending(false);
+    }
+  }
+
+  return (
+    <form
+      action={(formData) => {
+        void handleSubmit(formData);
+      }}
+      className="auth-card"
+    >
+      <div className="auth-copy">
+        <p className="eyebrow">{isSignUp ? "Create account" : "Welcome back"}</p>
+        <h1>{isSignUp ? "Create your account" : "Sign in to your workspace"}</h1>
+        <p className="lede">
+          {isSignUp
+            ? "Start from a minimal SaaS baseline with auth, billing, and strong project structure."
+            : "Use your email and password to continue into the app."}
+        </p>
+      </div>
+
+      <div className="auth-fields">
+        {isSignUp ? (
+          <label className="field">
+            <span>Name</span>
+            <input name="name" type="text" placeholder="Ada Lovelace" required />
+          </label>
+        ) : null}
+
+        <label className="field">
+          <span>Email</span>
+          <input name="email" type="email" placeholder="you@example.com" required />
+        </label>
+
+        <label className="field">
+          <span>Password</span>
+          <input
+            name="password"
+            type="password"
+            placeholder="At least 8 characters"
+            minLength={8}
+            required
+          />
+        </label>
+      </div>
+
+      {error ? <p className="form-error">{error}</p> : null}
+
+      <button type="submit" className="auth-button" disabled={isPending}>
+        {isPending ? "Working..." : isSignUp ? "Create account" : "Sign in"}
+      </button>
+
+      <p className="auth-switch">
+        {isSignUp ? "Already have an account?" : "Need an account?"}{" "}
+        <Link href={isSignUp ? "/sign-in" : "/sign-up"}>
+          {isSignUp ? "Sign in" : "Create one"}
+        </Link>
+      </p>
+    </form>
+  );
+}

package/templates/blank/src/components/auth/sign-out-button.tsx

@@ -0,0 +1,29 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+
+import { authClient } from "@/lib/auth-client";
+
+export function SignOutButton() {
+  const router = useRouter();
+  const [isPending, setIsPending] = useState(false);
+
+  async function handleSignOut() {
+    setIsPending(true);
+
+    try {
+      await authClient.signOut();
+      router.push("/sign-in");
+      router.refresh();
+    } finally {
+      setIsPending(false);
+    }
+  }
+
+  return (
+    <button type="button" className="btn-ghost" onClick={() => void handleSignOut()}>
+      {isPending ? "Signing out..." : "Sign out"}
+    </button>
+  );
+}

package/templates/blank/src/db/index.ts

@@ -0,0 +1,16 @@
+import "server-only";
+
+import { drizzle } from "__DRIZZLE_DRIVER_IMPORT__";
+__DATABASE_CLIENT_IMPORT__
+
+import { env } from "@/lib/env";
+
+__DATABASE_GLOBAL_BLOCK__
+
+const client = __DATABASE_CLIENT_EXPRESSION__;
+
+if (env.NODE_ENV !== "production") {
+__DATABASE_DEV_CACHE__
+}
+
+export const db = __DATABASE_DRIZZLE_EXPRESSION__;

package/templates/blank/src/db/schema/auth.ts

@@ -0,0 +1,4 @@
+// This file is intentionally minimal.
+// Run `pnpm auth:generate` to replace it with Better Auth's generated Drizzle schema.
+
+export {};

package/templates/blank/src/db/schema/index.ts

@@ -0,0 +1,2 @@
+export * from "./auth";
+export * from "./projects";

package/templates/blank/src/db/schema/projects.ts

@@ -0,0 +1,17 @@
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+
+export const projects = pgTable("projects", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  slug: text("slug").notNull().unique(),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  })
+    .defaultNow()
+    .notNull(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  })
+    .defaultNow()
+    .notNull()
+});

package/templates/blank/src/db/seeds/index.ts

@@ -0,0 +1,28 @@
+import { db } from "@/db";
+import { projects } from "@/db/schema";
+
+const shouldSeedDemoData = ["yes"].includes("__SEED_DEMO_DATA__");
+
+async function main() {
+  if (!shouldSeedDemoData) {
+    console.log("Demo seed data disabled.");
+    return;
+  }
+
+  await db
+    .insert(projects)
+    .values({
+      id: "project-demo",
+      name: "Demo Project",
+      slug: "demo-project"
+    })
+    .onConflictDoNothing();
+
+  console.log("Database seed complete.");
+}
+
+main().catch((error) => {
+  console.error("Database seed failed.");
+  console.error(error);
+  process.exit(1);
+});

package/templates/blank/src/lib/auth-client.ts

@@ -0,0 +1,5 @@
+"use client";
+
+import { createAuthClient } from "better-auth/react";
+
+export const authClient = createAuthClient();

package/templates/blank/src/lib/auth-session.ts

@@ -0,0 +1,11 @@
+import "server-only";
+
+import { headers } from "next/headers";
+
+import { auth } from "./auth";
+
+export async function getSession() {
+  return auth.api.getSession({
+    headers: await headers()
+  });
+}

package/templates/blank/src/lib/auth.ts

@@ -0,0 +1,23 @@
+import "server-only";
+
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+
+import { db } from "../db";
+import { env } from "./env";
+import * as schema from "../db/schema";
+
+export const auth = betterAuth({
+  appName: "__PROJECT_NAME__",
+  baseURL: env.BETTER_AUTH_URL,
+  secret: env.BETTER_AUTH_SECRET,
+  trustedOrigins: [env.NEXT_PUBLIC_APP_URL],
+  database: drizzleAdapter(db, {
+    provider: "pg",
+    schema
+  }),
+  emailAndPassword: {
+    enabled: true,
+    autoSignIn: true
+  }
+});

package/templates/blank/src/lib/billing/index.ts

@@ -0,0 +1,37 @@
+import "server-only";
+
+import { env } from "@/lib/env";
+
+__BILLING_PROVIDER_IMPORTS__
+
+import type { BillingProvider, BillingProviderName } from "./types";
+
+export function getBillingProviderName(input?: string): BillingProviderName {
+  if (input === "stripe" || input === "polar") {
+    return input;
+  }
+
+  if (env.BILLING_PROVIDER === "stripe" || env.BILLING_PROVIDER === "polar") {
+    return env.BILLING_PROVIDER;
+  }
+
+  if (env.BILLING_PROVIDER === "both") {
+    return "stripe";
+  }
+
+  throw new Error("Billing is disabled for this project.");
+}
+
+export function getBillingProvider(input?: string): BillingProvider {
+  const provider = getBillingProviderName(input);
+  const billingProviderFactories: Partial<Record<BillingProviderName, () => BillingProvider>> = {
+__BILLING_PROVIDER_FACTORIES__
+  };
+  const factory = billingProviderFactories[provider];
+
+  if (!factory) {
+    throw new Error(`Billing provider is not installed: ${provider}.`);
+  }
+
+  return factory();
+}

package/templates/blank/src/lib/billing/providers/polar.ts

@@ -0,0 +1,80 @@
+import "server-only";
+
+import { env } from "@/lib/env";
+
+import type {
+  BillingProvider,
+  CheckoutSessionInput,
+  PortalSessionInput,
+  WebhookInput
+} from "../types";
+
+function getPolarApiBaseUrl() {
+  return env.POLAR_SERVER === "production"
+    ? "https://api.polar.sh/v1"
+    : "https://sandbox-api.polar.sh/v1";
+}
+
+async function polarFetch<T>(pathname: string, body: Record<string, unknown>) {
+  if (!env.POLAR_ACCESS_TOKEN) {
+    throw new Error("POLAR_ACCESS_TOKEN is required for Polar billing.");
+  }
+
+  const response = await fetch(`${getPolarApiBaseUrl()}${pathname}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${env.POLAR_ACCESS_TOKEN}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+
+  if (!response.ok) {
+    const message = await response.text();
+    throw new Error(`Polar request failed: ${message}`);
+  }
+
+  return (await response.json()) as T;
+}
+
+export class PolarBillingProvider implements BillingProvider {
+  async createCheckoutSession(input: CheckoutSessionInput) {
+    if (!env.POLAR_PRODUCT_ID) {
+      throw new Error("POLAR_PRODUCT_ID is required for Polar checkout.");
+    }
+
+    const checkout = await polarFetch<{ url?: string }>("/checkouts", {
+      products: [env.POLAR_PRODUCT_ID],
+      external_customer_id: input.userId,
+      customer_email: input.customerEmail,
+      success_url: input.successUrl,
+      metadata: {
+        userId: input.userId
+      }
+    });
+
+    if (!checkout.url) {
+      throw new Error("Polar did not return a checkout URL.");
+    }
+
+    return { url: checkout.url };
+  }
+
+  async createCustomerPortalSession(input: PortalSessionInput) {
+    const session = await polarFetch<{ customer_portal_url?: string }>("/customer-sessions/", {
+      external_customer_id: input.userId
+    });
+
+    if (!session.customer_portal_url) {
+      throw new Error("Polar did not return a customer portal URL.");
+    }
+
+    return { url: session.customer_portal_url };
+  }
+
+  async handleWebhook(_input: WebhookInput) {
+    throw new Error(
+      "Polar webhook verification is intentionally left for follow-up implementation after confirming your webhook signing strategy."
+    );
+  }
+}

package/templates/blank/src/lib/billing/providers/stripe.ts

@@ -0,0 +1,77 @@
+import "server-only";
+
+import Stripe from "stripe";
+
+import { env } from "@/lib/env";
+
+import type {
+  BillingProvider,
+  CheckoutSessionInput,
+  PortalSessionInput,
+  WebhookInput
+} from "../types";
+
+let stripeClient: Stripe | null = null;
+
+function getStripe() {
+  if (!env.STRIPE_SECRET_KEY) {
+    throw new Error("STRIPE_SECRET_KEY is required for Stripe billing.");
+  }
+
+  stripeClient ??= new Stripe(env.STRIPE_SECRET_KEY);
+  return stripeClient;
+}
+
+export class StripeBillingProvider implements BillingProvider {
+  async createCheckoutSession(input: CheckoutSessionInput) {
+    if (!env.STRIPE_PRICE_ID) {
+      throw new Error("STRIPE_PRICE_ID is required for Stripe checkout.");
+    }
+
+    const stripe = getStripe();
+    const session = await stripe.checkout.sessions.create({
+      mode: "subscription",
+      line_items: [
+        {
+          price: env.STRIPE_PRICE_ID,
+          quantity: 1
+        }
+      ],
+      customer_email: input.customerEmail,
+      success_url: input.successUrl,
+      cancel_url: input.cancelUrl,
+      allow_promotion_codes: true,
+      metadata: {
+        userId: input.userId
+      }
+    });
+
+    if (!session.url) {
+      throw new Error("Stripe did not return a checkout URL.");
+    }
+
+    return { url: session.url };
+  }
+
+  async createCustomerPortalSession(
+    _input: PortalSessionInput
+  ): Promise<{ url: string }> {
+    throw new Error(
+      "Stripe portal requires a persisted Stripe customer ID. Add customer mapping before enabling portal access."
+    );
+  }
+
+  async handleWebhook(input: WebhookInput) {
+    if (!env.STRIPE_WEBHOOK_SECRET) {
+      throw new Error("STRIPE_WEBHOOK_SECRET is required for Stripe webhooks.");
+    }
+
+    const signature = input.headers.get("stripe-signature");
+    if (!signature) {
+      throw new Error("Missing Stripe signature header.");
+    }
+
+    const stripe = getStripe();
+    stripe.webhooks.constructEvent(input.rawBody, signature, env.STRIPE_WEBHOOK_SECRET);
+  }
+}

package/templates/blank/src/lib/billing/types.ts

@@ -0,0 +1,25 @@
+export type BillingProviderName = "stripe" | "polar";
+
+export type CheckoutSessionInput = {
+  customerEmail: string;
+  successUrl: string;
+  cancelUrl: string;
+  userId: string;
+};
+
+export type PortalSessionInput = {
+  customerEmail: string;
+  returnUrl: string;
+  userId: string;
+};
+
+export type WebhookInput = {
+  headers: Headers;
+  rawBody: string;
+};
+
+export interface BillingProvider {
+  createCheckoutSession(input: CheckoutSessionInput): Promise<{ url: string }>;
+  createCustomerPortalSession(input: PortalSessionInput): Promise<{ url: string }>;
+  handleWebhook(input: WebhookInput): Promise<void>;
+}

package/templates/blank/src/lib/email/index.ts

@@ -0,0 +1,19 @@
+import "server-only";
+
+__EMAIL_PROVIDER_IMPORTS__
+
+__EMAIL_ENV_IMPORT__
+
+import type { EmailTemplateResult } from "./templates";
+
+__EMAIL_PROVIDER_SETUP__
+
+__EMAIL_FROM_ADDRESS_HELPER__
+
+export async function sendEmail(__EMAIL_SEND_SIGNATURE__: {
+  to: string | string[];
+  template: EmailTemplateResult;
+}) {
+  void __EMAIL_SEND_SIGNATURE__;
+__EMAIL_SEND_IMPLEMENTATION__
+}

package/templates/blank/src/lib/email/templates.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+
+import { createWelcomeEmailTemplate } from "@/lib/email/templates";
+
+describe("createWelcomeEmailTemplate", () => {
+  it("includes the app name in the subject", () => {
+    const template = createWelcomeEmailTemplate({
+      appName: "Skit",
+      recipientName: "Ada"
+    });
+
+    expect(template.subject).toContain("Skit");
+    expect(template.text).toContain("Ada");
+  });
+});

package/templates/blank/src/lib/email/templates.ts

@@ -0,0 +1,40 @@
+export type EmailTemplateResult = {
+  subject: string;
+  text: string;
+  html: string;
+};
+
+export function createWelcomeEmailTemplate(input: {
+  appName: string;
+  recipientName?: string | null;
+}): EmailTemplateResult {
+  const greeting = input.recipientName ? `Hi ${input.recipientName},` : "Hi there,";
+
+  return {
+    subject: `Welcome to ${input.appName}`,
+    text: `${greeting}\n\nYour starter app is ready. Auth, billing, and the core project structure are already in place.\n\nNext step: sign in and continue building.\n`,
+    html: `<p>${greeting}</p><p>Your starter app is ready. Auth, billing, and the core project structure are already in place.</p><p>Next step: sign in and continue building.</p>`
+  };
+}
+
+export function createPasswordResetPlaceholderTemplate(input: {
+  appName: string;
+  resetUrl: string;
+}): EmailTemplateResult {
+  return {
+    subject: `Reset your ${input.appName} password`,
+    text: `Use this link to reset your password: ${input.resetUrl}`,
+    html: `<p>Use this link to reset your password:</p><p><a href="${input.resetUrl}">${input.resetUrl}</a></p>`
+  };
+}
+
+export function createBillingUpdatePlaceholderTemplate(input: {
+  appName: string;
+  provider: string;
+}): EmailTemplateResult {
+  return {
+    subject: `${input.appName} billing update`,
+    text: `A billing event was received from ${input.provider}. Replace this placeholder with your real billing notification workflow.`,
+    html: `<p>A billing event was received from <strong>${input.provider}</strong>.</p><p>Replace this placeholder with your real billing notification workflow.</p>`
+  };
+}

package/templates/blank/src/lib/env.ts

@@ -0,0 +1,80 @@
+import "server-only";
+
+import { z } from "zod";
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+  NEXT_PUBLIC_APP_URL: z.string().url(),
+  BETTER_AUTH_URL: z.string().url(),
+  DATABASE_URL: z.string().min(1),
+  BETTER_AUTH_SECRET: z.string().min(1),
+  BILLING_PROVIDER: z.enum(["stripe", "polar", "both", "none"]).default("stripe"),
+  EMAIL_PROVIDER: z.enum(["resend", "none"]).default("resend"),
+  RESEND_API_KEY: z.string().min(1).optional(),
+  EMAIL_FROM: z.string().min(1).optional(),
+  STRIPE_PRICE_ID: z.string().min(1).optional(),
+  STRIPE_SECRET_KEY: z.string().min(1).optional(),
+  STRIPE_WEBHOOK_SECRET: z.string().min(1).optional(),
+  POLAR_ACCESS_TOKEN: z.string().min(1).optional(),
+  POLAR_ORGANIZATION_ID: z.string().min(1).optional(),
+  POLAR_PRODUCT_ID: z.string().min(1).optional(),
+  POLAR_SERVER: z.enum(["production", "sandbox"]).default("sandbox"),
+  POLAR_WEBHOOK_SECRET: z.string().min(1).optional()
+});
+
+type Env = z.infer<typeof envSchema>;
+
+let cachedEnv: Env | null = null;
+const isBuildRuntime =
+  process.env.npm_lifecycle_event === "build" ||
+  process.env.NEXT_PHASE === "phase-production-build";
+
+function readRequiredValue(name: string, fallback: string) {
+  const value = process.env[name];
+
+  if (value) {
+    return value;
+  }
+
+  if (isBuildRuntime) {
+    return fallback;
+  }
+
+  return value;
+}
+
+function parseEnv(): Env {
+  return envSchema.parse({
+    NODE_ENV: process.env.NODE_ENV,
+    NEXT_PUBLIC_APP_URL: readRequiredValue("NEXT_PUBLIC_APP_URL", "http://localhost:3000"),
+    BETTER_AUTH_URL: readRequiredValue("BETTER_AUTH_URL", "http://localhost:3000"),
+    DATABASE_URL: readRequiredValue(
+      "DATABASE_URL",
+      "postgresql://postgres:postgres@localhost:5432/skit"
+    ),
+    BETTER_AUTH_SECRET: readRequiredValue("BETTER_AUTH_SECRET", "build-placeholder-secret"),
+    BILLING_PROVIDER: process.env.BILLING_PROVIDER,
+    EMAIL_PROVIDER: process.env.EMAIL_PROVIDER,
+    RESEND_API_KEY: process.env.RESEND_API_KEY,
+    EMAIL_FROM: process.env.EMAIL_FROM,
+    STRIPE_PRICE_ID: process.env.STRIPE_PRICE_ID,
+    STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY,
+    STRIPE_WEBHOOK_SECRET: process.env.STRIPE_WEBHOOK_SECRET,
+    POLAR_ACCESS_TOKEN: process.env.POLAR_ACCESS_TOKEN,
+    POLAR_ORGANIZATION_ID: process.env.POLAR_ORGANIZATION_ID,
+    POLAR_PRODUCT_ID: process.env.POLAR_PRODUCT_ID,
+    POLAR_SERVER: process.env.POLAR_SERVER,
+    POLAR_WEBHOOK_SECRET: process.env.POLAR_WEBHOOK_SECRET
+  });
+}
+
+export function getEnv(): Env {
+  cachedEnv ??= parseEnv();
+  return cachedEnv;
+}
+
+export const env = new Proxy({} as Env, {
+  get(_target, property) {
+    return getEnv()[property as keyof Env];
+  }
+});

package/templates/blank/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "es2022"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "baseUrl": ".",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "plugins": [{ "name": "next" }],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": ["node_modules"]
+}