abdellah0l-stack 1.0.1

package/template/src/lib/auth-client.ts

@@ -0,0 +1,7 @@
+import { createAuthClient } from "better-auth/react"
+
+// authentication client to manage user sessions and auth state
+export const authClient = createAuthClient({
+    baseURL: "http://localhost:3000/api/auth",
+});
+

package/template/src/lib/auth.ts

@@ -0,0 +1,50 @@
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { db } from "@/drizzle/db";
+import { nextCookies } from "better-auth/next-js";
+import { headers } from "next/headers";
+
+// authentication instance to be used in API routes and server-side functions
+export const auth = betterAuth({
+    basePath: "/api/v1/auth",
+    database: drizzleAdapter(db, {
+        provider: "pg",
+    }),
+    emailAndPassword: {
+        enabled: true,
+    },
+    socialProviders: {
+        github: {
+            clientId: process.env.GITHUB_CLIENT_ID as string || "",
+            clientSecret: process.env.GITHUB_CLIENT_SECRET as string || "",
+        },
+        google: {
+            clientId: process.env.GOOGLE_CLIENT_ID as string || "",
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET as string || "",
+        },
+    },
+    session: {
+        cookieCache: {
+            enabled: true,
+            maxAge: 60 * 5, // 5 minutes
+        }
+    },
+    plugins: [nextCookies()],
+});
+
+// get full session data
+export async function getSession() {
+    try {
+        const headersList = await headers();
+        
+        // Try to get session using the built-in better-auth session handling
+        const session = await auth.api.getSession({
+            headers: headersList,
+        });
+        
+        return session;
+    } catch (error) {
+        console.error('Error getting session:', error);
+        return null;
+    }
+}

package/template/src/lib/use-mobile.ts

@@ -0,0 +1,29 @@
+"use client";
+
+import { useState, useEffect } from "react";
+
+// a custom hook to determine if the current device is mobile based on window width
+export function useMobile() {
+  const [isMobile, setIsMobile] = useState(false);
+
+  useEffect(() => {
+    
+    const checkIsMobile = () => {
+      setIsMobile(window.innerWidth < 768);
+    };
+
+    
+    checkIsMobile();
+
+    
+    window.addEventListener("resize", checkIsMobile);
+
+    
+    return () => {
+      window.removeEventListener("resize", checkIsMobile);
+    };
+  }, []);
+
+  return isMobile;
+}
+

package/template/src/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/src/middleware.ts

@@ -0,0 +1,14 @@
+import { NextResponse, type NextRequest } from "next/server"
+
+// middleware function that runs on every request matching the specified matcher
+
+export async function middleware(request: NextRequest) {
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: [
+    // match all paths except for static files and API routes
+    "/((?!_next|[^?]*\\.(?:html?|css|js(?!on)|jpe?g|webp|png|gif|svg|ttf|woff2?|ico|csv|docx?|xlsx?|zip|webmanifest)).*)",
+  ],
+}

package/template/src/server/index.ts

@@ -0,0 +1,13 @@
+import { router } from "./trpc";
+import { postsRouter } from "./routers/posts";
+import { usersRouter } from "./routers/users";
+
+// main application router combining all individual routers
+export const appRouter = router({
+  // example routers
+  posts: postsRouter,
+  users: usersRouter,
+});
+
+// export the type definition of the app router
+export type AppRouter = typeof appRouter;

package/template/src/server/routers/posts.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { router, protectedProcedure, publicProcedure } from "../trpc";
+import { db } from "@/drizzle/db";
+import { posts } from "@/drizzle/schema";
+import { eq, desc } from "drizzle-orm";
+
+// this is an example router file for managing blog posts
+
+export const postsRouter = router({
+  // Get all posts
+  list: publicProcedure.query(async () => {
+    return await db.select().from(posts).orderBy(desc(posts.createdAt));
+  }),
+
+  // Get single post by ID
+  byId: publicProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .query(async ({ input }) => {
+      const result = await db
+        .select()
+        .from(posts)
+        .where(eq(posts.id, input.id));
+      return result[0] ?? null;
+    }),
+
+  // Create a new post (protected)
+  create: protectedProcedure
+    .input(
+      z.object({
+        title: z.string().min(1).max(255),
+        content: z.string().min(1),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const [post] = await db
+        .insert(posts)
+        .values({
+          title: input.title,
+          content: input.content,
+          userId: ctx.user.id,
+        })
+        .returning();
+      return post;
+    }),
+
+  // Update a post (protected, owner only)
+  update: protectedProcedure
+    .input(
+      z.object({
+        id: z.string().uuid(),
+        title: z.string().min(1).max(255).optional(),
+        content: z.string().min(1).optional(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const [existing] = await db
+        .select()
+        .from(posts)
+        .where(eq(posts.id, input.id));
+
+      if (!existing || existing.userId !== ctx.user.id) {
+        throw new Error("Not authorized");
+      }
+
+      const [updated] = await db
+        .update(posts)
+        .set({
+          ...(input.title && { title: input.title }),
+          ...(input.content && { content: input.content }),
+        })
+        .where(eq(posts.id, input.id))
+        .returning();
+
+      return updated;
+    }),
+
+  // Delete a post (protected, owner only)
+  delete: protectedProcedure
+    .input(z.object({ id: z.string().uuid() }))
+    .mutation(async ({ ctx, input }) => {
+      const [existing] = await db
+        .select()
+        .from(posts)
+        .where(eq(posts.id, input.id));
+
+      if (!existing || existing.userId !== ctx.user.id) {
+        throw new Error("Not authorized");
+      }
+
+      await db.delete(posts).where(eq(posts.id, input.id));
+      return { success: true };
+    }),
+});

package/template/src/server/routers/users.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { router, publicProcedure, protectedProcedure } from "../trpc";
+import { db } from "@/drizzle/db";
+import { user } from "@/drizzle/schema/auth-schema";
+import { eq } from "drizzle-orm";
+
+// this is an example router file for managing users
+// the ctx in protectedProcedure contains the authenticated user's session info
+// and the input is actually a parameter passed to the procedure from the client-side
+
+export const usersRouter = router({
+  // Get current user profile
+  me: protectedProcedure.query(async ({ ctx }) => {
+    const [profile] = await db
+      .select()
+      .from(user)
+      .where(eq(user.id, ctx.user.id));
+    return profile ?? null;
+  }),
+
+  // Get user by ID (public)
+  byId: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input }) => {
+      const [profile] = await db
+        .select({
+          id: user.id,
+          name: user.name,
+          image: user.image,
+          createdAt: user.createdAt,
+        })
+        .from(user)
+        .where(eq(user.id, input.id));
+      return profile ?? null;
+    }),
+
+  // Update current user profile
+  update: protectedProcedure
+    .input(
+      z.object({
+        name: z.string().min(1).max(100).optional(),
+        image: z.string().url().optional(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const [updated] = await db
+        .update(user)
+        .set({
+          ...(input.name && { name: input.name }),
+          ...(input.image && { image: input.image }),
+        })
+        .where(eq(user.id, ctx.user.id))
+        .returning();
+      return updated;
+    }),
+});

package/template/src/server/trpc.ts

@@ -0,0 +1,38 @@
+import { initTRPC, TRPCError } from '@trpc/server';
+import { getSession } from '@/lib/auth';
+import { aj } from '@/lib/arcjet';
+
+// create the tRPC context which includes session data and request info
+export const createTRPCContext = async (opts: { req: Request }) => {
+  const session = await getSession();
+  return {
+    session,
+    req: opts.req,
+    arcjet: aj,
+  };
+};
+
+// initialize tRPC with the created context
+const t = initTRPC.context<typeof createTRPCContext>().create();
+
+// create the main router and procedures for tRPC
+export const router = t.router;
+
+// public procedure that does not require authentication
+export const publicProcedure = t.procedure;
+
+// protected procedure that requires the user to be logged in
+export const protectedProcedure = t.procedure.use(async ({ ctx, next }) => {
+  if (!ctx.session || !ctx.session.user) {
+    throw new TRPCError({ 
+      code: 'UNAUTHORIZED',
+      message: 'You must be logged in to access this feature.'
+    });
+  }
+
+  return next({
+    ctx: {
+      session: { ...ctx.session, user: ctx.session.user },
+    },
+  });
+});

package/template/src/types/index.ts

@@ -0,0 +1,10 @@
+// Add ur custom types here
+
+export interface Post {
+  id: string;
+  title: string;
+  content: string;
+  userId: string;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/template/src/utils/trpc.ts

@@ -0,0 +1,5 @@
+import { createTRPCReact } from '@trpc/react-query';
+import type { AppRouter } from '@/server';
+
+// create a tRPC React hook for the AppRouter, the job of this file is to provide type-safe hooks for tRPC in React components
+export const trpc = createTRPCReact<AppRouter>();

package/template/src/utils/uploadthing.ts

@@ -0,0 +1,10 @@
+import {
+  generateUploadButton,
+} from "@uploadthing/react";
+
+import type { OurFileRouter } from "../app/api/v1/uploadthing/core";
+
+// UploadButton component for uploading files using Uploadthing
+export const UploadButton = generateUploadButton<OurFileRouter>({
+    url: "/api/v1/uploadthing",
+});

package/template/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    "**/*.mts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}