shipd 0.1.2 → 0.1.4

package/features/auth/lib/auth.ts

@@ -0,0 +1,295 @@
+import { db } from "@/db/drizzle";
+import { account, session, user, verification } from "@/db/schema";
+import { eq } from "drizzle-orm";
+// Subscription is optional (only if payments module is installed)
+// We'll check for it at runtime in the webhook handler
+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,
+    },
+  }),
+  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
+                // Only if subscription table exists (payments module installed)
+                // Dynamically import subscription table
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let subscriptionTable: any;
+                try {
+                  const schemaModule = await import("@/db/schema");
+                  if ('subscription' in schemaModule && schemaModule.subscription) {
+                    subscriptionTable = schemaModule.subscription;
+                  } else {
+                    console.warn("⚠️  Subscription table not found. Install payments module to enable subscription webhooks.");
+                    return;
+                  }
+                } catch {
+                  console.warn("⚠️  Subscription table not found. Install payments module to enable subscription webhooks.");
+                  return;
+                }
+                
+                await db
+                  .insert(subscriptionTable)
+                  .values(subscriptionData)
+                  .onConflictDoUpdate({
+                    target: subscriptionTable.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(eq(user.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(eq(user.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/features/auth/lib/email-stub.ts

@@ -0,0 +1,55 @@
+/**
+ * Email stub for auth module
+ * 
+ * This provides minimal email functionality when the full email module is not installed.
+ * Email sending will be logged to console in development.
+ */
+
+interface EmailOptions {
+  to: string;
+  subject: string;
+  url?: string;
+  user?: { email: string; name?: string };
+}
+
+/**
+ * Send password reset email (stub)
+ */
+export async function sendPasswordResetEmail(
+  email: string,
+  url: string
+): Promise<void> {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(`📧 [Email Stub] Password reset email would be sent to ${email}`);
+    console.log(`   Reset URL: ${url}`);
+    console.log(`   Install the email module for actual email sending.`);
+  }
+  // In production, this would fail silently or you should install the email module
+}
+
+/**
+ * Send subscription confirmation email (stub)
+ */
+export async function sendSubscriptionConfirmationEmail(
+  email: string,
+  subscriptionDetails: any
+): Promise<void> {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(`📧 [Email Stub] Subscription confirmation email would be sent to ${email}`);
+    console.log(`   Install the email module for actual email sending.`);
+  }
+}
+
+/**
+ * Send payment failed email (stub)
+ */
+export async function sendPaymentFailedEmail(
+  email: string,
+  errorDetails: any
+): Promise<void> {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(`📧 [Email Stub] Payment failed email would be sent to ${email}`);
+    console.log(`   Install the email module for actual email sending.`);
+  }
+}
+

package/features/auth/lib/email.ts

@@ -0,0 +1,47 @@
+/**
+ * Email functions for auth module
+ * 
+ * This is a minimal email implementation that logs to console.
+ * Install the full email module (Resend) for production email sending.
+ */
+
+/**
+ * Send password reset email
+ */
+export async function sendPasswordResetEmail(
+  email: string,
+  url: string
+): Promise<void> {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(`📧 [Email] Password reset email would be sent to ${email}`);
+    console.log(`   Reset URL: ${url}`);
+    console.log(`   Install the email module (Resend) for actual email sending.`);
+  }
+  // In production without email module, this fails silently
+  // Install the email module for production use
+}
+
+/**
+ * Send subscription confirmation email
+ */
+export async function sendSubscriptionConfirmationEmail(
+  email: string
+): Promise<void> {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(`📧 [Email] Subscription confirmation email would be sent to ${email}`);
+    console.log(`   Install the email module (Resend) for actual email sending.`);
+  }
+}
+
+/**
+ * Send payment failed email
+ */
+export async function sendPaymentFailedEmail(
+  email: string
+): Promise<void> {
+  if (process.env.NODE_ENV === 'development') {
+    console.log(`📧 [Email] Payment failed email would be sent to ${email}`);
+    console.log(`   Install the email module (Resend) for actual email sending.`);
+  }
+}
+

package/features/auth/middleware.patch.ts

@@ -0,0 +1,43 @@
+/**
+ * Auth Middleware Patch
+ * 
+ * This file contains the middleware logic for authentication.
+ * When the auth module is appended, this will be merged into the base middleware.ts
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getSessionCookie } from "better-auth/cookies";
+
+/**
+ * Apply auth middleware logic
+ * This function should be called from the base middleware
+ */
+export function applyAuthMiddleware(
+  request: NextRequest,
+  baseResponse: NextResponse
+): NextResponse | null {
+  const sessionCookie = getSessionCookie(request);
+  const { pathname } = request.nextUrl;
+
+  // Don't redirect from sign-in/sign-up pages to avoid redirect loops
+  if (["/sign-in", "/sign-up"].includes(pathname)) {
+    return null; // Let base middleware handle it
+  }
+
+  // Redirect unauthenticated users from protected routes
+  const protectedRoutes = ["/dashboard"]; // Can be customized
+  const isProtectedRoute = protectedRoutes.some(route => pathname.startsWith(route));
+
+  if (isProtectedRoute && !sessionCookie) {
+    const returnTo = encodeURIComponent(pathname);
+    return NextResponse.redirect(new URL(`/sign-in?returnTo=${returnTo}`, request.url));
+  }
+
+  return null; // Continue with base middleware
+}
+
+/**
+ * Middleware matcher configuration for auth
+ */
+export const matcher = ["/dashboard/:path*", "/sign-in", "/sign-up"];
+

package/features/database/README.md

@@ -0,0 +1,256 @@
+# Database Module - Integration Guide
+
+**Module Version:** 1.0.0  
+**Last Updated:** 2025-12-22  
+**Standalone:** ✅ Yes (base database setup)
+
+---
+
+## Overview
+
+This module sets up PostgreSQL database connectivity using Drizzle ORM. It provides the foundation for database operations and can be extended by other modules (auth, payments) that add their own tables.
+
+**Key Features:**
+- PostgreSQL connection with Drizzle ORM
+- Drizzle Kit configuration for migrations
+- Base schema structure (extended by other modules)
+- Database scripts (push, generate, migrate, studio)
+- Support for Neon, Supabase, or any Postgres database
+
+---
+
+## Files Added
+
+### Configuration
+- `drizzle.config.ts` - Drizzle Kit configuration
+- `db/drizzle.ts` - Database connection setup
+- `db/schema.ts` - Base schema file (modules will add tables here)
+
+### Migrations
+- `db/migrations/` - Directory for database migrations
+
+---
+
+## Dependencies
+
+### Package Dependencies
+The following packages will be added to `package.json`:
+- `postgres@^3.4.4` - PostgreSQL client
+- `drizzle-orm@^0.41.0` - Drizzle ORM
+
+### Dev Dependencies
+- `drizzle-kit@^0.31.0` - Drizzle migration and studio tools
+
+### Package Scripts
+The following scripts will be added to `package.json`:
+- `db:push` - Push schema changes to database (development)
+- `db:generate` - Generate migration files
+- `db:migrate` - Run migrations
+- `db:studio` - Open Drizzle Studio (database GUI)
+
+---
+
+## Environment Variables
+
+Add this to your `.env.local`:
+
+```env
+# Database
+DATABASE_URL="postgresql://user:password@host:port/database"
+```
+
+**Required Variables:**
+- `DATABASE_URL` - PostgreSQL connection string
+
+**Where to get it:**
+- **Neon**: [neon.tech](https://neon.tech) - Free tier available
+- **Supabase**: [supabase.com](https://supabase.com) - Free tier available
+- **Local Postgres**: `postgresql://postgres:password@localhost:5432/mydb`
+- **Any Postgres**: Standard PostgreSQL connection string format
+
+---
+
+## Manual Integration Steps
+
+If you're appending this module to an existing project, follow these steps:
+
+### Step 1: Install Dependencies
+
+```bash
+npm install
+# or
+pnpm install
+# or
+yarn install
+```
+
+The append command automatically adds missing dependencies to `package.json`, but you need to install them.
+
+### Step 2: Add Environment Variable
+
+1. Copy `.env.example` to `.env.local` (if not exists)
+2. Add `DATABASE_URL` with your PostgreSQL connection string
+3. Get a database URL from:
+   - [Neon](https://neon.tech) (recommended for development)
+   - [Supabase](https://supabase.com)
+   - Your own PostgreSQL server
+
+### Step 3: Verify Installation
+
+1. Check that `drizzle.config.ts` exists in project root
+2. Check that `db/drizzle.ts` and `db/schema.ts` exist
+3. Verify package.json has database scripts
+
+### Step 4: Initialize Database (Optional)
+
+If you want to create an initial migration:
+
+```bash
+npm run db:generate
+npm run db:push
+```
+
+**Note:** The base schema is empty. Tables will be added when you install other modules (auth, payments, etc.).
+
+---
+
+## Usage Examples
+
+### Using the Database Connection
+
+```typescript
+import { db } from "@/db/drizzle";
+
+// Example query (after auth module adds user table)
+const users = await db.select().from(user);
+```
+
+### Generating Migrations
+
+After adding tables (via auth or payments modules):
+
+```bash
+# Generate migration files
+npm run db:generate
+
+# Review the generated migration in db/migrations/
+
+# Push to database (development)
+npm run db:push
+
+# Or run migrations (production)
+npm run db:migrate
+```
+
+### Opening Drizzle Studio
+
+```bash
+npm run db:studio
+```
+
+This opens a web-based database GUI at `http://localhost:4983`
+
+---
+
+## Customization
+
+### Database Connection
+
+Edit `db/drizzle.ts` to customize the connection:
+
+```typescript
+// For Supabase compatibility (prepared statements disabled)
+const client = postgres(connectionString, { prepare: false });
+
+// For other Postgres providers
+const client = postgres(connectionString);
+```
+
+### Schema Location
+
+The schema file is at `db/schema.ts`. Other modules will add their tables here. You can also add custom tables:
+
+```typescript
+// db/schema.ts
+export const myCustomTable = pgTable("my_custom_table", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  // ...
+});
+```
+
+---
+
+## Integration Points
+
+### Files That May Need Manual Updates
+
+**db/schema.ts**:
+- Other modules (auth, payments) will add their tables to this file
+- You can add custom tables here as well
+
+**drizzle.config.ts**:
+- Usually doesn't need changes
+- Modify if you need custom migration settings
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue:** "Missing DATABASE_URL" error
+**Solution:**
+- Ensure `DATABASE_URL` is set in `.env.local`
+- Restart your dev server after adding env vars
+- Check the connection string format
+
+**Issue:** "Connection refused" or "ECONNREFUSED"
+**Solution:**
+- Verify your database is running
+- Check the connection string is correct
+- For cloud databases, ensure your IP is whitelisted (if required)
+
+**Issue:** "relation does not exist" error
+**Solution:**
+- Run migrations: `npm run db:push` or `npm run db:migrate`
+- Ensure other modules (auth, payments) have been installed and their tables added
+
+**Issue:** Supabase connection issues
+**Solution:**
+- The connection is configured with `prepare: false` for Supabase compatibility
+- If issues persist, check Supabase connection pooling settings
+
+---
+
+## Next Steps
+
+After installing this module:
+
+1. Set up your database (Neon, Supabase, or local)
+2. Add `DATABASE_URL` to `.env.local`
+3. Install Auth module (will add user/session tables)
+4. Install Payments module (will add subscription table)
+5. Run `npm run db:push` to create tables
+
+---
+
+## Related Modules
+
+This module is required by:
+- **Auth Module** - Adds user, session, account, verification tables
+- **Payments Module** - Adds subscription table
+
+This module works well with:
+- **Auth Module** - For user authentication
+- **Payments Module** - For subscription management
+
+---
+
+## Module Status
+
+✅ **Standalone Package** - Can be installed independently  
+✅ **Base Setup** - Provides foundation for other modules  
+✅ **Ready to Use** - Works immediately after append  
+✅ **Well Documented** - Comprehensive integration guide
+