auth-simple 1.0.0 → 1.0.1

package/111/app/api/auth/[...nextauth]/route.js

@@ -0,0 +1,4 @@
+
+    import { handlers } from "@/auth";
+    export const { GET, POST } = handlers;
+    

package/111/app/api/users/[id]/route.js

@@ -0,0 +1,49 @@
+
+    // app/api/users/[id]/route.js
+    import { NextResponse } from "next/server";
+    import { connectDB } from "@/lib/db";
+    import User from "@/models/User";
+
+    // READ ONE (GET /api/users/:id)
+    export async function GET(req, { params }) {
+    const { id } = await params;
+    try {
+        await connectDB();
+        const user = await User.findById(id).select("-passwordHash");
+        if (!user)
+        return NextResponse.json({ error: "User not found" }, { status: 404 });
+        return NextResponse.json(user);
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+    }
+
+    // UPDATE (PUT /api/users/:id)
+    export async function PUT(req, { params }) {
+    const { id } = await params;
+    try {
+        await connectDB();
+        const body = await req.json();
+        const user = await User.findByIdAndUpdate(id, body, { new: true });
+        if (!user)
+        return NextResponse.json({ error: "User not found" }, { status: 404 });
+        return NextResponse.json(user);
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 400 });
+    }
+    }
+
+    // DELETE (DELETE /api/users/:id)
+    export async function DELETE(req, { params }) {
+    const { id } = await params;
+    try {
+        await connectDB();
+        const user = await User.findByIdAndDelete(id);
+        if (!user)
+        return NextResponse.json({ error: "User not found" }, { status: 404 });
+        return NextResponse.json({ message: "User deleted successfully" });
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+    }
+    

package/111/app/api/users/route.js

@@ -0,0 +1,36 @@
+
+    import { NextResponse } from "next/server";
+    import { connectDB } from "@/lib/db";
+    import User from "@/models/User";
+    import bcrypt from "bcryptjs";
+
+    // CREATE (POST /api/users)
+    export async function POST(req) {
+    try {
+        await connectDB();
+        const body = await req.json();
+        const { email, password, image } = body;
+        const salt = await bcrypt.genSalt(10);
+        const hash = await bcrypt.hash(password, salt);
+        const user = await User.create({
+        email,
+        passwordHash: hash,
+        image: image || null,
+        });
+        return NextResponse.json(user, { status: 201 });
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 400 });
+    }
+    }
+
+    // READ ALL (GET /api/users)
+    export async function GET() {
+    try {
+        await connectDB();
+        const users = await User.find().select("-passwordHash");
+        return NextResponse.json(users);
+    } catch (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+    }
+    

package/111/app/login/page.jsx

@@ -0,0 +1,66 @@
+
+    "use client";
+
+    import { signIn } from "next-auth/react";
+    import { useState } from "react";
+
+    export default function Login() {
+    const [email, setEmail] = useState("");
+    const [password, setPassword] = useState("");
+
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        await signIn("credentials", {
+        email,
+        password,
+        redirect: true,
+        callbackUrl: "/",
+        });
+    };
+
+    return (
+        <div className="flex items-center justify-center min-h-screen">
+        <div className="w-sm shadow-2xl/50 rounded-lg p-6">
+            <h1 className="text-2xl flex justify-center py-2 border-b-2 border-black">
+            Login
+            </h1>
+            <form
+            onSubmit={handleSubmit}
+            className="flex flex-col gap-4 py-4 border-b-1 border-black mb-4"
+            >
+            <input
+                className="p-2 rounded outline-none focus:ring-0 focus:border-gray-500 border border-gray-300"
+                type="email"
+                placeholder="Email"
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                required
+            />
+            <input
+                className="p-2 rounded outline-none focus:ring-0 focus:border-gray-500 border border-gray-300"
+                type="password"
+                placeholder="Password"
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+                required
+            />
+            <button
+                className="bg-gray-500 text-white p-2 rounded hover:bg-gray-600 cursor-pointer"
+                type="submit"
+            >
+                Login
+            </button>
+            </form>
+
+            <hr />
+            <button
+            onClick={() => signIn("google", { callbackUrl: "/" })}
+            className="bg-gray-500 text-white p-2 rounded hover:bg-gray-600 cursor-pointer w-full"
+            >
+            Sign in with Google
+            </button>
+        </div>
+        </div>
+    );
+    }
+    

package/111/app/register/page.jsx

@@ -0,0 +1,75 @@
+
+    "use client";
+
+    import { useState } from "react";
+
+    export default function Register() {
+    const [email, setEmail] = useState("");
+    const [password, setPassword] = useState("");
+    const [image, setImage] = useState("");
+
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+
+        const res = await fetch("/api/users", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            email,
+            password,
+            image: image || null,
+        }),
+        });
+
+        if (res.ok) {
+        alert("✅ User registered successfully!");
+        } else {
+        console.log("Registration failed", await res.json());
+        alert("❌ Registration failed");
+        }
+    };
+
+    return (
+        <div className="flex items-center justify-center min-h-screen">
+        <div className="w-sm shadow-2xl/50 rounded-lg p-6">
+            <h1 className="text-2xl flex justify-center py-2 border-b-2 border-black">
+            Register
+            </h1>
+            <form
+            className="flex flex-col gap-4 py-4 border-b-1 border-black mb-4"
+            onSubmit={handleSubmit}
+            >
+            <input
+                className="p-2 rounded outline-none focus:ring-0 focus:border-gray-500 border border-gray-300"
+                type="email"
+                placeholder="Email"
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                required
+            />
+            <input
+                className="p-2 rounded outline-none focus:ring-0 focus:border-gray-500 border border-gray-300"
+                type="password"
+                placeholder="Password"
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+                required
+            />
+            <button
+                className="bg-gray-500 text-white p-2 rounded hover:bg-gray-600 cursor-pointer"
+                type="submit"
+            >
+                Register
+            </button>
+            </form>
+            <button
+            onClick={() => signIn("google", { callbackUrl: "/" })}
+            className="bg-gray-500 text-white p-2 rounded hover:bg-gray-600 cursor-pointer w-full"
+            >
+            Sign in with Google
+            </button>
+        </div>
+        </div>
+    );
+    }
+    

package/111/auth.js

@@ -0,0 +1,88 @@
+
+    import NextAuth from "next-auth";
+    import CredentialsProvider from "next-auth/providers/credentials";
+    import GoogleProvider from "next-auth/providers/google";
+    import { connectDB } from "./lib/db";
+    import { MongoDBAdapter } from "@auth/mongodb-adapter";
+    import clientPromise from "@/lib/mongodb";
+    import User from "@/models/User";
+    import bcrypt from "bcryptjs";
+
+    export const { handlers, signIn, signOut, auth } = NextAuth({
+    adapter: MongoDBAdapter(clientPromise),
+    providers: [
+        GoogleProvider({
+        clientId: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        }),
+        CredentialsProvider({
+        name: "Credentials",
+        credentials: {
+            email: { label: "Email", type: "text" },
+            password: { label: "Password", type: "password" },
+        },
+        async authorize(credentials) {
+            try {
+            await connectDB();
+            const user = await User.findOne({ email: credentials.email });
+            if (!user) throw new Error("No user found with this email");
+
+            const isValid = await bcrypt.compare(
+                credentials.password,
+                user.passwordHash,
+            );
+
+            if (!isValid) return null;
+
+            return {
+                id: user._id.toString(),
+                email: user.email,
+                role: user.role,
+                image: user.image,
+            };
+            } catch (err) {
+            console.error("Credentials.authorize error", err);
+            throw err;
+            }
+        },
+        }),
+    ],
+    callbacks: {
+        async jwt({ token, user }) {
+        if (user) {
+            token.id = user.id;
+            token.role = user.role || "user"; // Assign roles dynamically
+        }
+        return token;
+        },
+        async session({ session, token }) {
+        session.user.id = token.id;
+        session.user.role = token.role || "user"; // Ensure role is included in session
+        return session;
+        },
+    },
+    session: {
+        strategy: "jwt",
+        maxAge: 30 * 24 * 60 * 60, // 30 days
+    },
+    pages: {
+        signIn: "/auth/signin",
+        signOut: "/auth/signout",
+        error: "/auth/error",
+    },
+    events: {
+        async signIn({ user }) {
+        console.log("User signed in:", user);
+        },
+        async signOut({ token }) {
+        console.log("User signed out:", token);
+        },
+    },
+    debug: process.env.NODE_ENV === "development",
+    theme: {
+        colorScheme: "auto", // "auto", "dark", "light"
+        brandColor: "#0070f3",
+        logo: "/logo.png",
+    },
+    });
+    

package/111/components/Menu.jsx

@@ -0,0 +1,37 @@
+
+    "use client";
+
+    import { signIn, signOut, useSession } from "next-auth/react";
+    import Link from "next/link";
+
+    export default function Menu() {
+    const { data: session, status } = useSession();
+
+    if (status === "loading") {
+        return <p>Loading...</p>;
+    }
+
+    return (
+        <nav className="fixed top-0 flex gap-1 items-center justify-end w-full p-4 bg-black/20">
+        {!session ? (
+            <>
+            <Link href="/login" className="text-gray-700 hover:text-gray-900 m-2">
+                Login
+            </Link>
+            <Link href="/register">Register</Link>
+            </>
+        ) : (
+            <>
+            <span>{session.user?.email}</span>
+            <button
+                onClick={() => signOut({ callbackUrl: "/" })}
+                className="bg-gray-500 text-white p-2 rounded hover:bg-gray-600 cursor-pointer ml-2"
+            >
+                Logout
+            </button>
+            </>
+        )}
+        </nav>
+    );
+    }
+    

package/111/lib/db.js

@@ -0,0 +1,38 @@
+
+    import mongoose from "mongoose";
+
+    const MONGODB_URI = process.env.MONGODB_URI;
+
+    if (!MONGODB_URI) {
+    throw new Error(
+        "❌ Please define the MONGODB_URI environment variable inside .env.local",
+    );
+    }
+
+    /**
+     * Global cache to prevent multiple connections in dev mode
+     */
+    let cached = global.mongoose;
+
+    if (!cached) {
+    cached = global.mongoose = { conn: null, promise: null };
+    }
+
+    export async function connectDB() {
+    if (cached.conn) {
+        return cached.conn;
+    }
+
+    if (!cached.promise) {
+        cached.promise = mongoose
+        .connect(MONGODB_URI, {
+            bufferCommands: false,
+        })
+        .then((mongoose) => mongoose);
+    }
+
+    cached.conn = await cached.promise;
+    console.log("✅ MongoDB connected");
+    return cached.conn;
+    }
+    

package/111/lib/mongodb.js

@@ -0,0 +1,27 @@
+
+    // lib/mongodb.js
+    import { MongoClient } from "mongodb";
+
+    const uri = process.env.MONGODB_URI;
+    const options = {};
+
+    let client;
+    let clientPromise;
+
+    if (!uri) {
+    throw new Error("❌ Please add your Mongo URI to .env.local");
+    }
+
+    if (process.env.NODE_ENV === "development") {
+    if (!global._mongoClientPromise) {
+        client = new MongoClient(uri, options);
+        global._mongoClientPromise = client.connect();
+    }
+    clientPromise = global._mongoClientPromise;
+    } else {
+    client = new MongoClient(uri, options);
+    clientPromise = client.connect();
+    }
+
+    export default clientPromise;
+    

package/111/models/User.js

@@ -0,0 +1,29 @@
+
+    import mongoose from "mongoose";
+
+    const userSchema = new mongoose.Schema(
+    {
+        email: {
+        type: String,
+        required: true,
+        unique: true,
+        },
+        passwordHash: {
+        type: String,
+        required: true,
+        },
+        role: {
+        type: String,
+        enum: ["user", "admin"],
+        default: "user",
+        },
+        image: {
+        type: String,
+        default: null,
+        },
+    },
+    { timestamps: true },
+    );
+
+    export default mongoose.models.User || mongoose.model("User", userSchema);
+    

package/111/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "111",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+}

package/index.js

@@ -2,9 +2,27 @@
 
 import { files } from "./files.js";
 import { createFile } from "./functions.js";
+import { execSync } from "child_process";
 
 files.forEach(({ fileName, body }) => {
   createFile(fileName, body);
 });
 
 console.log("✅ All files created!");
+
+const dependencies = [
+  "mongodb",
+  "mongoose",
+  "@auth/mongodb-adapter",
+  "next-auth",
+  "bcryptjs",
+];
+
+console.log("📦 Installing dependencies...");
+
+try {
+  execSync(`npm install ${dependencies.join(" ")}`, { stdio: "inherit" });
+  console.log("✅ Dependencies installed!");
+} catch (error) {
+  console.error("❌ Failed to install dependencies:", error.message);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auth-simple",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -12,6 +12,7 @@
   "type": "module",
   "dependencies": {
     "@auth/mongodb-adapter": "^3.11.1",
+    "auth-simple": "^1.0.0",
     "bcryptjs": "^3.0.3",
     "mongodb": "^7.1.0",
     "mongoose": "^9.2.3",