next-ts-cli 1.0.3

package/template/extras/stripe/webhook/stripe/route.ts

@@ -0,0 +1,89 @@
+/* =============================================================================================
+
+This page is a minimal boilerplate for managing the Stripe subscription system with your website.
+
+If you need a non-subscription based system, the webhook configuration will be differnt, 
+so check the Stripe documentation for more information.
+
+================================================================================================ */
+import { headers } from "next/headers";
+import { NextResponse } from "next/server";
+import { stripe } from "@/lib/stripe";
+import type Stripe from "stripe";
+
+export async function POST(req: Request) {
+	const body = await req.text();
+	const headersList = await headers();
+	const signature = headersList.get("Stripe-Signature") as string;
+
+	let event: Stripe.Event;
+
+	try {
+		event = stripe().webhooks.constructEvent(
+			body,
+			signature,
+			process.env.STRIPE_WEBHOOK_SECRET as string
+		);
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		return new NextResponse(`Webhook Error: ${message}`, { status: 400 });
+	}
+
+	try {
+		switch (event.type) {
+			// When a customer completes checkout
+			case "checkout.session.completed": {
+				try {
+					// Do something
+				} catch (e) {
+					return new NextResponse(`Error: ${e}`, { status: 500 });
+				}
+				break;
+			}
+
+			// When a new subscription is created
+			case "customer.subscription.created": {
+				const subscription = event.data.object as Stripe.Subscription;
+                // Do something, usually create record in DB
+				break;
+			}
+
+			// When a subscription is updated
+			case "customer.subscription.updated": {
+				const subscription = event.data.object as Stripe.Subscription;
+                // Do something, usually update record in DB, when subscription is renewed/stopped, etc.
+				break;
+			}
+
+			// When a subscription is specifically cancelled/deleted
+			case "customer.subscription.deleted": {
+				const subscription = event.data.object as Stripe.Subscription;
+                // Do something, usually delete record in DB, when subscription is cancelled/deleted, etc.
+				break;
+			}
+
+			// When a trial is about to end (3 days before)
+			case "customer.subscription.trial_will_end": {
+				const subscription = event.data.object as Stripe.Subscription;
+                // Do something, usually warn the user via mail or something else
+				break;
+			}
+
+			// Invoice events for payment tracking
+			case "invoice.payment_succeeded": {
+				// Do something, usually log invoices info somewhere
+				break;
+			}
+
+            // When a payment fails
+			case "invoice.payment_failed": {
+				// Do something, usually warn the user via mail or something else
+				break;
+			}
+		}
+
+		return new NextResponse(null, { status: 200 });
+	} catch (_) {
+		return new NextResponse("Webhook handler error", { status: 500 });
+	}
+}

package/template/extras/supabase/client.ts

@@ -0,0 +1,8 @@
+import { createBrowserClient } from "@supabase/ssr";
+
+export function createClient() {
+  return createBrowserClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
+  );
+}

package/template/extras/supabase/getAuth.ts

@@ -0,0 +1,50 @@
+import { createClient } from "@/lib/supabase/server";
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { cookies } from "next/headers";
+
+export type ProfileModel = {
+	id: string;
+	fullName: string;
+	email: string;
+	avatar: string;
+};
+
+export type UseAuthProps =
+	| {
+			isLoggedIn: true;
+			user: ProfileModel;
+			supabase: SupabaseClient;
+	  }
+	| {
+			isLoggedIn: false;
+			user: null;
+			supabase: SupabaseClient;
+	  };
+
+/**
+ * Utility hook to check if the user is logged in or not
+ *
+ * It works **only Server Side**
+ * @returns {UseAuthProps} Auth object {@link UseAuthProps}
+ */
+export const getAuth = async (): Promise<UseAuthProps> => {
+	const cookie = cookies();
+	const supabase = createClient(cookie);
+
+	const {
+		data: { user },
+	} = await supabase.auth.getUser();
+
+	if (user) {
+		const userModel: ProfileModel = {
+			id: user.id,
+			fullName: user.user_metadata?.name ?? user.user_metadata?.user_name,
+			email: user.email || "",
+			avatar: user.user_metadata.avatar_url || "",
+		};
+
+		return { isLoggedIn: true, user: userModel, supabase };
+	} else {
+		return { isLoggedIn: false, user: null, supabase };
+	}
+};

package/template/extras/supabase/proxy.ts

@@ -0,0 +1,70 @@
+import { createServerClient } from "@supabase/ssr";
+import { NextResponse, type NextRequest } from "next/server";
+
+export async function updateSession(request: NextRequest) {
+  let supabaseResponse = NextResponse.next({
+    request,
+  });
+
+
+  // With Fluid compute, don't put this client in a global environment
+  // variable. Always create a new one on each request.
+  const supabase = createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return request.cookies.getAll();
+        },
+        setAll(cookiesToSet) {
+          cookiesToSet.forEach(({ name, value }) =>
+            request.cookies.set(name, value),
+          );
+          supabaseResponse = NextResponse.next({
+            request,
+          });
+          cookiesToSet.forEach(({ name, value, options }) =>
+            supabaseResponse.cookies.set(name, value, options),
+          );
+        },
+      },
+    },
+  );
+
+  // Do not run code between createServerClient and
+  // supabase.auth.getClaims(). A simple mistake could make it very hard to debug
+  // issues with users being randomly logged out.
+
+  // IMPORTANT: If you remove getClaims() and you use server-side rendering
+  // with the Supabase client, your users may be randomly logged out.
+  const { data } = await supabase.auth.getClaims();
+  const user = data?.claims;
+
+  if (
+    request.nextUrl.pathname !== "/" &&
+    !user &&
+    !request.nextUrl.pathname.startsWith("/login") &&
+    !request.nextUrl.pathname.startsWith("/auth")
+  ) {
+    // no user, potentially respond by redirecting the user to the login page
+    const url = request.nextUrl.clone();
+    url.pathname = "/auth/login";
+    return NextResponse.redirect(url);
+  }
+
+  // IMPORTANT: You *must* return the supabaseResponse object as it is.
+  // If you're creating a new response object with NextResponse.next() make sure to:
+  // 1. Pass the request in it, like so:
+  //    const myNewResponse = NextResponse.next({ request })
+  // 2. Copy over the cookies, like so:
+  //    myNewResponse.cookies.setAll(supabaseResponse.cookies.getAll())
+  // 3. Change the myNewResponse object to fit your needs, but avoid changing
+  //    the cookies!
+  // 4. Finally:
+  //    return myNewResponse
+  // If this is not done, you may be causing the browser and server to go out
+  // of sync and terminate the user's session prematurely!
+
+  return supabaseResponse;
+}

package/template/extras/supabase/server.ts

@@ -0,0 +1,34 @@
+import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+
+/**
+ * Especially important if using Fluid compute: Don't put this client in a
+ * global variable. Always create a new client within each function when using
+ * it.
+ */
+export async function createClient() {
+  const cookieStore = await cookies();
+
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(({ name, value, options }) =>
+              cookieStore.set(name, value, options),
+            );
+          } catch {
+            // The `setAll` method was called from a Server Component.
+            // This can be ignored if you have proxy refreshing
+            // user sessions.
+          }
+        },
+      },
+    },
+  );
+}

package/template/extras/supabase/storage.ts

@@ -0,0 +1,90 @@
+/* ==============================
+Utility functions for Supabase storage.
+======================================
+ */
+
+import { createClient } from "./client";
+
+export interface UploadResult {
+	url: string;
+	path: string;
+}
+
+export interface DeleteResult {
+	success: boolean;
+	error?: string;
+}
+
+/**
+ * Upload a file to Supabase storage.
+ * @param bucket - The name of the bucket to upload the file to.
+ * @param file - The file to upload.
+ * @param fileName - The name of the file to upload.
+ * @returns The URL of the uploaded file and the path of the file.
+ * @throws An error if the file could not be uploaded.
+ * @example
+ * const result = await uploadFile("my-bucket", "my-file.txt", "my-file.txt");
+ * if (result.url) {
+ *   console.log("File uploaded successfully");
+ * } else {
+ *   console.error(result.error);
+ * }
+ */
+export const uploadFile = async (
+	bucket: string,
+	file: File,
+	fileName: string
+): Promise<{ url: string; path: string } | { error: string }> => {
+	try {
+		const supabase = createClient();
+
+		// Upload file to Supabase storage
+		const { error } = await supabase.storage.from(bucket).upload(fileName, file, {
+			cacheControl: "3600",
+			upsert: false,
+		});
+
+		if (error) {
+			return { error: error.message };
+		}
+
+		const { data: urlData } = supabase.storage.from(bucket).getPublicUrl(fileName);
+
+		return { url: urlData.publicUrl, path: fileName };
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : "Unknown error" };
+	}
+};
+
+/**
+ * Delete a file from Supabase storage.
+ * @param bucket - The name of the bucket to delete the file from.
+ * @param fileName - The name of the file to delete.
+ * @returns True if the file was deleted successfully, false otherwise.
+ * @throws An error if the file could not be deleted.
+ * @example
+ * const result = await deleteFile("my-bucket", "my-file.txt");
+ * if (result.success) {
+ *   console.log("File deleted successfully");
+ * } else {
+ *   console.error(result.error);
+ * }
+ */
+export const deleteFile = async (
+	bucket: string,
+	fileName: string
+): Promise<{ success: boolean } | { error: string }> => {
+	try {
+		const supabase = createClient();
+
+		const { error } = await supabase.storage.from(bucket).remove([fileName]);
+
+		if (error) {
+			return { error: error.message };
+		}
+
+		return { success: true };
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : "Unknown error" };
+	}
+};

package/template/extras/vercel-ai/route.ts

@@ -0,0 +1,12 @@
+import { streamText, UIMessage, convertToModelMessages } from 'ai';
+
+export async function POST(req: Request) {
+  const { messages }: { messages: UIMessage[] } = await req.json();
+
+  const result = streamText({
+    model: "openai/gpt-5.2-chat-latest", // or any other model you want to use
+    messages: await convertToModelMessages(messages),
+  });
+
+  return result.toUIMessageStreamResponse();
+}