shipd 0.1.0

package/template/lib/auth.ts

@@ -0,0 +1,276 @@
+import { db } from "@/db/drizzle";
+import { account, session, subscription, user, verification } from "@/db/schema";
+import {
+  checkout,
+  polar,
+  portal,
+  usage,
+  webhooks,
+} from "@polar-sh/better-auth";
+import { Polar } from "@polar-sh/sdk";
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { nextCookies } from "better-auth/next-js";
+import {
+  sendPasswordResetEmail,
+  sendSubscriptionConfirmationEmail,
+  sendPaymentFailedEmail,
+} from "@/lib/email";
+
+// Utility function to safely parse dates
+function safeParseDate(value: string | Date | null | undefined): Date | null {
+  if (!value) return null;
+  if (value instanceof Date) return value;
+  return new Date(value);
+}
+
+// Check if Polar is configured
+const isPolarConfigured = !!(
+  process.env.POLAR_ACCESS_TOKEN &&
+  process.env.POLAR_WEBHOOK_SECRET &&
+  process.env.NEXT_PUBLIC_STARTER_TIER &&
+  process.env.NEXT_PUBLIC_STARTER_SLUG
+);
+
+if (!isPolarConfigured && process.env.NODE_ENV === "development") {
+  console.warn(
+    "⚠️  Polar.sh not configured - subscription features disabled. Configure POLAR_* env vars to enable payments.",
+  );
+}
+
+const polarClient = isPolarConfigured
+  ? new Polar({
+      accessToken: process.env.POLAR_ACCESS_TOKEN,
+    })
+  : null;
+
+export const auth = betterAuth({
+  trustedOrigins: [`${process.env.NEXT_PUBLIC_APP_URL}`],
+  allowedDevOrigins: [`${process.env.NEXT_PUBLIC_APP_URL}`],
+  cookieCache: {
+    enabled: true,
+    maxAge: 5 * 60, // Cache duration in seconds
+  },
+  database: drizzleAdapter(db, {
+    provider: "pg",
+    schema: {
+      user,
+      session,
+      account,
+      verification,
+      subscription,
+    },
+  }),
+  emailAndPassword: {
+    enabled: true,
+    sendResetPassword: async ({ user, url }) => {
+      // Send password reset email
+      await sendPasswordResetEmail(user.email, url);
+    },
+  },
+  user: {
+    additionalFields: {
+      name: {
+        type: "string",
+        required: false,
+      },
+    },
+  },
+  socialProviders: {
+    google: {
+      clientId: process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+    },
+  },
+  // TODO: Implement welcome emails via a custom sign-up API route
+  // Better Auth hooks API may have changed - using webhook approach instead
+  plugins: [
+    ...(isPolarConfigured && polarClient
+      ? [
+          polar({
+            client: polarClient,
+            createCustomerOnSignUp: true,
+            use: [
+              checkout({
+                products: [
+                  {
+                    productId: process.env.NEXT_PUBLIC_STARTER_TIER!,
+                    slug: process.env.NEXT_PUBLIC_STARTER_SLUG!,
+                  },
+                ],
+                successUrl: `${process.env.NEXT_PUBLIC_APP_URL}/${process.env.POLAR_SUCCESS_URL}`,
+                authenticatedUsersOnly: true,
+              }),
+              portal(),
+              usage(),
+              webhooks({
+                secret: process.env.POLAR_WEBHOOK_SECRET!,
+          onPayload: async ({ data, type }) => {
+            if (
+              type === "subscription.created" ||
+              type === "subscription.active" ||
+              type === "subscription.canceled" ||
+              type === "subscription.revoked" ||
+              type === "subscription.uncanceled" ||
+              type === "subscription.updated"
+            ) {
+              console.log("🎯 Processing subscription webhook:", type);
+              console.log("📦 Payload data:", JSON.stringify(data, null, 2));
+
+              try {
+                // STEP 1: Extract user ID from customer data
+                const userId = data.customer?.externalId;
+                // STEP 2: Build subscription data
+                const subscriptionData = {
+                  id: data.id,
+                  createdAt: new Date(data.createdAt),
+                  modifiedAt: safeParseDate(data.modifiedAt),
+                  amount: data.amount,
+                  currency: data.currency,
+                  recurringInterval: data.recurringInterval,
+                  status: data.status,
+                  currentPeriodStart:
+                    safeParseDate(data.currentPeriodStart) || new Date(),
+                  currentPeriodEnd:
+                    safeParseDate(data.currentPeriodEnd) || new Date(),
+                  cancelAtPeriodEnd: data.cancelAtPeriodEnd || false,
+                  canceledAt: safeParseDate(data.canceledAt),
+                  startedAt: safeParseDate(data.startedAt) || new Date(),
+                  endsAt: safeParseDate(data.endsAt),
+                  endedAt: safeParseDate(data.endedAt),
+                  customerId: data.customerId,
+                  productId: data.productId,
+                  discountId: data.discountId || null,
+                  checkoutId: data.checkoutId || "",
+                  customerCancellationReason:
+                    data.customerCancellationReason || null,
+                  customerCancellationComment:
+                    data.customerCancellationComment || null,
+                  metadata: data.metadata
+                    ? JSON.stringify(data.metadata)
+                    : null,
+                  customFieldData: data.customFieldData
+                    ? JSON.stringify(data.customFieldData)
+                    : null,
+                  userId: userId as string | null,
+                };
+
+                console.log("💾 Final subscription data:", {
+                  id: subscriptionData.id,
+                  status: subscriptionData.status,
+                  userId: subscriptionData.userId,
+                  amount: subscriptionData.amount,
+                });
+
+                // STEP 3: Use Drizzle's onConflictDoUpdate for proper upsert
+                await db
+                  .insert(subscription)
+                  .values(subscriptionData)
+                  .onConflictDoUpdate({
+                    target: subscription.id,
+                    set: {
+                      modifiedAt: subscriptionData.modifiedAt || new Date(),
+                      amount: subscriptionData.amount,
+                      currency: subscriptionData.currency,
+                      recurringInterval: subscriptionData.recurringInterval,
+                      status: subscriptionData.status,
+                      currentPeriodStart: subscriptionData.currentPeriodStart,
+                      currentPeriodEnd: subscriptionData.currentPeriodEnd,
+                      cancelAtPeriodEnd: subscriptionData.cancelAtPeriodEnd,
+                      canceledAt: subscriptionData.canceledAt,
+                      startedAt: subscriptionData.startedAt,
+                      endsAt: subscriptionData.endsAt,
+                      endedAt: subscriptionData.endedAt,
+                      customerId: subscriptionData.customerId,
+                      productId: subscriptionData.productId,
+                      discountId: subscriptionData.discountId,
+                      checkoutId: subscriptionData.checkoutId,
+                      customerCancellationReason:
+                        subscriptionData.customerCancellationReason,
+                      customerCancellationComment:
+                        subscriptionData.customerCancellationComment,
+                      metadata: subscriptionData.metadata,
+                      customFieldData: subscriptionData.customFieldData,
+                      userId: subscriptionData.userId,
+                    },
+                  });
+
+                console.log("✅ Upserted subscription:", data.id);
+
+                // Send subscription emails based on event type
+                try {
+                  // Get user email from database
+                  if (userId) {
+                    const userRecord = await db
+                      .select()
+                      .from(user)
+                      .where((users) => users.id === userId)
+                      .limit(1);
+
+                    if (userRecord[0]?.email) {
+                      const userEmail = userRecord[0].email;
+
+                      // Send confirmation email for new or reactivated subscriptions
+                      if (
+                        type === "subscription.created" ||
+                        type === "subscription.active"
+                      ) {
+                        const amount = `$${(data.amount / 100).toFixed(2)}/${data.recurringInterval}`;
+                        await sendSubscriptionConfirmationEmail(
+                          userEmail,
+                          "Premium", // TODO: Get actual plan name from product
+                          amount
+                        );
+                        console.log("📧 Sent subscription confirmation email to:", userEmail);
+                      }
+                    }
+                  }
+                } catch (emailError) {
+                  console.error("📧 Failed to send subscription email:", emailError);
+                  // Don't throw - email failures shouldn't block webhook processing
+                }
+              } catch (error) {
+                console.error(
+                  "💥 Error processing subscription webhook:",
+                  error,
+                );
+                // Don't throw - let webhook succeed to avoid retries
+              }
+            }
+
+            // Handle payment failed events
+            if (type === "subscription.payment_failed") {
+              try {
+                const userId = data.customer?.externalId;
+                if (userId) {
+                  const userRecord = await db
+                    .select()
+                    .from(user)
+                    .where((users) => users.id === userId)
+                    .limit(1);
+
+                  if (userRecord[0]?.email) {
+                    const retryDate = new Date();
+                    retryDate.setDate(retryDate.getDate() + 3); // 3 days from now
+
+                    await sendPaymentFailedEmail(
+                      userRecord[0].email,
+                      "Premium", // TODO: Get actual plan name
+                      retryDate.toLocaleDateString()
+                    );
+                    console.log("📧 Sent payment failed email to:", userRecord[0].email);
+                  }
+                }
+              } catch (error) {
+                console.error("📧 Failed to send payment failed email:", error);
+              }
+            }
+          },
+        }),
+      ],
+    }),
+        ]
+      : []),
+    nextCookies(),
+  ],
+});

package/template/lib/email.ts

@@ -0,0 +1,118 @@
+import { Resend } from 'resend';
+
+// Check if email is configured
+const isEmailConfigured = !!process.env.RESEND_API_KEY;
+
+if (!isEmailConfigured && process.env.NODE_ENV === 'development') {
+  console.warn('⚠️  Resend not configured - email sending disabled. Set RESEND_API_KEY to enable emails.');
+}
+
+export const resend = isEmailConfigured ? new Resend(process.env.RESEND_API_KEY) : null;
+
+/**
+ * Send an email using Resend
+ * @param to - Recipient email address
+ * @param subject - Email subject line
+ * @param react - React email component
+ * @param from - Sender email (defaults to noreply@yourdomain.com)
+ */
+export async function sendEmail({
+  to,
+  subject,
+  react,
+  from = process.env.EMAIL_FROM || 'SaaS Scaffold <noreply@saas-scaffold.com>',
+}: {
+  to: string;
+  subject: string;
+  react: React.ReactElement;
+  from?: string;
+}) {
+  // Skip if email is not configured
+  if (!resend) {
+    console.log(`📧 Email not sent (Resend not configured): ${subject} to ${to}`);
+    return { success: true, skipped: true };
+  }
+
+  try {
+    const { data, error } = await resend.emails.send({
+      from,
+      to,
+      subject,
+      react,
+    });
+
+    if (error) {
+      console.error('Failed to send email:', error);
+      throw new Error(`Email send failed: ${error.message}`);
+    }
+
+    console.log('Email sent successfully:', data);
+    return { success: true, data };
+  } catch (error) {
+    console.error('Email send error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    };
+  }
+}
+
+/**
+ * Send welcome email to new users
+ */
+export async function sendWelcomeEmail(email: string, name?: string) {
+  const { WelcomeEmail } = await import('@/emails/welcome');
+
+  return sendEmail({
+    to: email,
+    subject: 'Welcome to SaaS Scaffold!',
+    react: WelcomeEmail({ userName: name || 'there' }),
+  });
+}
+
+/**
+ * Send password reset email
+ */
+export async function sendPasswordResetEmail(email: string, resetUrl: string) {
+  const { PasswordResetEmail } = await import('@/emails/password-reset');
+
+  return sendEmail({
+    to: email,
+    subject: 'Reset your password',
+    react: PasswordResetEmail({ resetUrl }),
+  });
+}
+
+/**
+ * Send subscription confirmation email
+ */
+export async function sendSubscriptionConfirmationEmail(
+  email: string,
+  planName: string,
+  amount: string
+) {
+  const { SubscriptionConfirmationEmail } = await import('@/emails/subscription-confirmation');
+
+  return sendEmail({
+    to: email,
+    subject: `Subscription confirmed: ${planName}`,
+    react: SubscriptionConfirmationEmail({ planName, amount }),
+  });
+}
+
+/**
+ * Send payment failed email
+ */
+export async function sendPaymentFailedEmail(
+  email: string,
+  planName: string,
+  retryDate: string
+) {
+  const { PaymentFailedEmail } = await import('@/emails/payment-failed');
+
+  return sendEmail({
+    to: email,
+    subject: 'Payment failed - Action required',
+    react: PaymentFailedEmail({ planName, retryDate }),
+  });
+}

package/template/lib/polar-products.ts

@@ -0,0 +1,49 @@
+import { Polar } from '@polar-sh/sdk';
+
+const polarClient = new Polar({
+  accessToken: process.env.POLAR_ACCESS_TOKEN!,
+});
+
+export interface ProductDetails {
+  id: string;
+  name: string;
+  description: string | null;
+  prices: Array<{
+    id: string;
+    amount: number;
+    currency: string;
+    recurring_interval: 'month' | 'year';
+  }>;
+}
+
+/**
+ * Fetch product details from Polar
+ */
+export async function getProductDetails(
+  productId: string
+): Promise<ProductDetails | null> {
+  try {
+    const product = await polarClient.products.get({
+      id: productId,
+    });
+
+    if (!product) {
+      return null;
+    }
+
+    return {
+      id: product.id,
+      name: product.name,
+      description: product.description || null,
+      prices: (product.prices || []).map((price) => ({
+        id: price.id,
+        amount: price.priceAmount || 0,
+        currency: price.priceCurrency || 'usd',
+        recurring_interval: (price.recurringInterval as 'month' | 'year') || 'month',
+      })),
+    };
+  } catch (error) {
+    console.error('Error fetching product from Polar:', error);
+    return null;
+  }
+}

package/template/lib/subscription.ts

@@ -0,0 +1,148 @@
+import { auth } from "@/lib/auth";
+import { db } from "@/db/drizzle";
+import { subscription } from "@/db/schema";
+import { eq } from "drizzle-orm";
+import { headers } from "next/headers";
+
+export type SubscriptionDetails = {
+  id: string;
+  productId: string;
+  status: string;
+  amount: number;
+  currency: string;
+  recurringInterval: string;
+  currentPeriodStart: Date;
+  currentPeriodEnd: Date;
+  cancelAtPeriodEnd: boolean;
+  canceledAt: Date | null;
+  organizationId: string | null;
+};
+
+export type SubscriptionDetailsResult = {
+  hasSubscription: boolean;
+  subscription?: SubscriptionDetails;
+  error?: string;
+  errorType?: "CANCELED" | "EXPIRED" | "GENERAL";
+};
+
+export async function getSubscriptionDetails(): Promise<SubscriptionDetailsResult> {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session?.user?.id) {
+      return { hasSubscription: false };
+    }
+
+    const userSubscriptions = await db
+      .select()
+      .from(subscription)
+      .where(eq(subscription.userId, session.user.id));
+
+    if (!userSubscriptions.length) {
+      return { hasSubscription: false };
+    }
+
+    // Get the most recent active subscription
+    const activeSubscription = userSubscriptions
+      .filter((sub) => sub.status === "active")
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+
+    if (!activeSubscription) {
+      // Check for canceled or expired subscriptions
+      const latestSubscription = userSubscriptions
+        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+
+      if (latestSubscription) {
+        const now = new Date();
+        const isExpired = new Date(latestSubscription.currentPeriodEnd) < now;
+        const isCanceled = latestSubscription.status === "canceled";
+
+        return {
+          hasSubscription: true,
+          subscription: {
+            id: latestSubscription.id,
+            productId: latestSubscription.productId,
+            status: latestSubscription.status,
+            amount: latestSubscription.amount,
+            currency: latestSubscription.currency,
+            recurringInterval: latestSubscription.recurringInterval,
+            currentPeriodStart: latestSubscription.currentPeriodStart,
+            currentPeriodEnd: latestSubscription.currentPeriodEnd,
+            cancelAtPeriodEnd: latestSubscription.cancelAtPeriodEnd,
+            canceledAt: latestSubscription.canceledAt,
+            organizationId: null,
+          },
+          error: isCanceled ? "Subscription has been canceled" : isExpired ? "Subscription has expired" : "Subscription is not active",
+          errorType: isCanceled ? "CANCELED" : isExpired ? "EXPIRED" : "GENERAL",
+        };
+      }
+
+      return { hasSubscription: false };
+    }
+
+    return {
+      hasSubscription: true,
+      subscription: {
+        id: activeSubscription.id,
+        productId: activeSubscription.productId,
+        status: activeSubscription.status,
+        amount: activeSubscription.amount,
+        currency: activeSubscription.currency,
+        recurringInterval: activeSubscription.recurringInterval,
+        currentPeriodStart: activeSubscription.currentPeriodStart,
+        currentPeriodEnd: activeSubscription.currentPeriodEnd,
+        cancelAtPeriodEnd: activeSubscription.cancelAtPeriodEnd,
+        canceledAt: activeSubscription.canceledAt,
+        organizationId: null,
+      },
+    };
+  } catch (error) {
+    console.error("Error fetching subscription details:", error);
+    return {
+      hasSubscription: false,
+      error: "Failed to load subscription details",
+      errorType: "GENERAL",
+    };
+  }
+}
+
+// Simple helper to check if user has an active subscription
+export async function isUserSubscribed(): Promise<boolean> {
+  const result = await getSubscriptionDetails();
+  return result.hasSubscription && result.subscription?.status === "active";
+}
+
+// Helper to check if user has access to a specific product/tier
+export async function hasAccessToProduct(productId: string): Promise<boolean> {
+  const result = await getSubscriptionDetails();
+  return (
+    result.hasSubscription &&
+    result.subscription?.status === "active" &&
+    result.subscription?.productId === productId
+  );
+}
+
+// Helper to get user's current subscription status
+export async function getUserSubscriptionStatus(): Promise<"active" | "canceled" | "expired" | "none"> {
+  const result = await getSubscriptionDetails();
+  
+  if (!result.hasSubscription) {
+    return "none";
+  }
+  
+  if (result.subscription?.status === "active") {
+    return "active";
+  }
+  
+  if (result.errorType === "CANCELED") {
+    return "canceled";
+  }
+  
+  if (result.errorType === "EXPIRED") {
+    return "expired";
+  }
+  
+  return "none";
+}

package/template/lib/upload-image.ts

@@ -0,0 +1,28 @@
+import {
+  S3Client,
+  PutObjectCommand,
+} from "@aws-sdk/client-s3";
+
+const r2 = new S3Client({
+  region: "auto", // required for R2
+  endpoint: `https://${process.env.CLOUDFLARE_ACCOUNT_ID}.r2.cloudflarestorage.com`,
+  credentials: {
+    accessKeyId: process.env.R2_UPLOAD_IMAGE_ACCESS_KEY_ID!,
+    secretAccessKey: process.env.R2_UPLOAD_IMAGE_SECRET_ACCESS_KEY!,
+  },
+});
+
+export const uploadImageAssets = async (buffer: Buffer, key: string) => {
+  await r2.send(
+    new PutObjectCommand({
+      Bucket: process.env.R2_UPLOAD_IMAGE_BUCKET_NAME!,
+      Key: key,
+      Body: buffer,
+      ContentType: "image/*",
+      ACL: "public-read", // optional if bucket is public
+    })
+  );
+
+  const publicUrl = `https://pub-6f0cf05705c7412b93a792350f3b3aa5.r2.dev/${key}`;
+  return publicUrl;
+};

package/template/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/template/middleware.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getSessionCookie } from "better-auth/cookies";
+
+export async function middleware(request: NextRequest) {
+  const sessionCookie = getSessionCookie(request);
+  const { pathname, searchParams } = request.nextUrl;
+
+  // /api/payments/webhooks is a webhook endpoint that should be accessible without authentication
+  if (pathname.startsWith("/api/payments/webhooks")) {
+    return NextResponse.next();
+  }
+
+  // Don't redirect from sign-in/sign-up pages to avoid redirect loops
+  // Users will be redirected after successful auth via callbackURL
+  if (["/sign-in", "/sign-up"].includes(pathname)) {
+    return NextResponse.next();
+  }
+
+  // Redirect unauthenticated users from dashboard to sign-in
+  if (!sessionCookie && pathname.startsWith("/dashboard")) {
+    const returnTo = encodeURIComponent(pathname);
+    return NextResponse.redirect(new URL(`/sign-in?returnTo=${returnTo}`, request.url));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ["/dashboard/:path*", "/sign-in", "/sign-up"],
+};

package/template/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/template/next.config.ts

@@ -0,0 +1,27 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+  reactStrictMode: false,
+  typescript: {
+    ignoreBuildErrors: true,
+  },
+  images: {
+    remotePatterns: [
+      {
+        protocol: "https",
+        hostname: "pub-6f0cf05705c7412b93a792350f3b3aa5.r2.dev",
+      },
+      {
+        protocol: "https",
+        hostname: "jdj14ctwppwprnqu.public.blob.vercel-storage.com",
+      },
+      {
+        protocol: "https",
+        hostname: "images.unsplash.com",
+      },
+    ],
+  },
+};
+
+export default nextConfig;