Yea

src/app/api2/[...slug]/route.ts

@@ -0,0 +1,53 @@
+'use server'
+
+import { MPost } from "@/model/Models";
+import { cookies } from "next/headers";
+
+
+export async function GET(request:Request, { params }: {params:{slug: string}}){
+    console.log(request);
+    const url:NextURL = request.url;
+    console.log(url);
+    console.log(request);
+    console.log(params);
+
+    
+    // @ts-ignore
+    cookies().set('name', 'lee');
+    return Response.json({
+        "a": "kanker",
+        "b": params
+    });
+}
+
+
+
+
+
+
+
+// export default async function handler(req:NextApiRequest, res:NextApiResponse) {
+//     await MPost.sync();
+//     switch (req.method) {
+//         case 'GET':
+//             const posts = await MPost.findAll();
+//             res.status(200).json(posts);
+//             break;
+//         case 'POST':
+//             try {
+//                 const post = await MPost.create({
+//                     title: req.body.title,
+//                     content: req.body.content,
+//                     createdAt: new Date(),
+//                     updatedAt: new Date(),
+//                 },{ fields: ['title','content'] });
+//                 const posts2 = await MPost.findAll();    
+//                 res.status(200).json(posts2);
+//             } catch (error) {
+//                 console.log(error)
+//             }
+//             break;
+//         default:
+//             break;
+//     }
+// }

src/app/api2/auth/route.ts

@@ -0,0 +1,78 @@
+'use server'
+
+import { Model } from "sequelize";
+import { cookies } from "next/headers";
+
+import { Auth, Post, User } from "@/model/sequelize/NewModels";
+
+
+import { APIError} from "@/api/error"
+import { UserAuth, parseBasicAuth, getAssociatedUser } from "@/api/user"
+
+
+async function tryAuth(request:Request){
+
+    // await User.sync();
+    await Auth.sync();
+
+    const auth:string|null = request.headers.get("authorization");
+
+    if(!auth){
+        return new Response("unauthorized",{status:403});
+    }
+
+    const userAuth = parseBasicAuth(auth);
+    const user = await getAssociatedUser(userAuth); 
+    
+    if (!user || !user.id)
+        return new Response("error",{status:500});
+
+    const authentication = await Auth.create({
+        user_id: user.id,
+    })
+
+    const foundAuth = await Auth.findOne({
+        include: 'user',
+        where: {
+            user_id: user.id
+        }
+    })
+    if(!foundAuth)
+        return new Response("error",{status:500});
+    
+
+    const kanker = await authentication.getUser();
+
+    // @ts-ignore
+    cookies().set('auth', JSON.stringify(authentication));
+
+    return new Response(
+        JSON.stringify(
+        {
+            credentials: userAuth,
+            auth: authentication,
+            kanker: kanker,
+            foundAuth: foundAuth
+        }),
+        { 
+            status: 200, 
+            headers:{
+                "Content-Type": "text/JSON" 
+            } 
+        }
+    ); 
+}
+
+export async function POST(request:Request){
+    try{
+        return await tryAuth(request);      
+    }
+    catch(e){
+        if (e instanceof APIError){
+            return new Response(e.info.responseText,{status:e.info.status});
+        }
+        else{
+            throw e;
+        }
+    }
+}

src/app/api2/post/[...slug]/route.ts

@@ -0,0 +1,34 @@
+'use server'
+
+import { APIError } from "@/api/error";
+import { Post } from "@/model/sequelize/NewModels";
+
+
+export async function tryFetchPost(request:Request, { params }: {params:{slug: string}}){
+    await Post.sync();
+
+    const foundPost = await Post.findOne({include:'user',where:{id:params.slug}});
+    
+    return new Response(JSON.stringify(foundPost),{ 
+            status: 200, 
+            headers:{
+                "Content-Type": "text/JSON" 
+            } 
+        }
+    ); 
+
+}
+
+export async function GET(request:Request, { params }: {params:{slug: string}}){
+    try{
+        return await tryFetchPost(request, { params });      
+    }
+    catch(e){
+        if (e instanceof APIError){
+            return new Response(e.info.responseText,{status:e.info.status});
+        }
+        else{
+            throw e;
+        }
+    }
+}

src/app/api2/post/route.ts

@@ -0,0 +1,104 @@
+'use server'
+
+import { APIError } from "@/api/error";
+import { Auth, Post, User } from "@/model/sequelize/NewModels";
+import { cookies } from "next/headers";
+import { where } from "sequelize";
+
+
+
+async function tryCreatePost(request:Request){
+    await Post.sync();
+
+
+    const requestBody = await request.json();
+
+    const authCookie = await cookies().get("auth");
+
+    if(!authCookie || !authCookie.value) throw new APIError({status:500,responseText: "missing auth cookie"});
+
+    const cookieJSON = authCookie.value;
+
+    const authObject = JSON.parse(cookieJSON);
+
+    const auth = await Auth.findOne({include: 'user', where:{token: authObject.token}});
+    
+    
+    if(!auth || !auth.user) throw new APIError({status:401,responseText: "Authentication Error"});
+
+    const user = auth.user;
+    
+
+
+    // return new Response(JSON.stringify({auth,user}),{status:200});
+
+
+    if (!requestBody) throw new APIError({status:500,responseText: "Empty request body"});
+    if (!requestBody.title) throw new APIError({status:500,responseText: "Missing post title"});
+    if (!requestBody.content) throw new APIError({status:500,responseText: "Missing post content"});
+    // if (!requestBody.user_id) throw new APIError({status:500,responseText: "Missing user id"});
+
+    const post = await Post.create({
+        content:requestBody.content,
+        user_id:user.id,
+        title:requestBody.title,
+        date:Date.now()
+    })
+
+    const foundPost = await Post.findOne({
+        include:"user",
+        where:{
+            id:post.id
+        }
+    })
+
+
+    return new Response(JSON.stringify(foundPost),{status:200});
+
+}
+
+export async function POST(request:Request){
+    try{
+        return await tryCreatePost(request);      
+    }
+    catch(e){
+        if (e instanceof APIError){
+            return new Response(e.info.responseText,{status:e.info.status});
+        }
+        else{
+            throw e;
+        }
+    }
+}
+
+
+async function tryFetchPosts(request:Request){
+
+    await Post.sync();
+
+    const foundPosts = await Post.findAll({
+        include: [{ 
+            association: 'user',
+            attributes:{exclude:['password','createdAt','updatedAt']}
+        }]
+    });
+
+    return new Response(JSON.stringify(foundPosts),{status:200});
+
+}
+
+
+export async function GET(request:Request){
+    try{
+        return await tryFetchPosts(request);      
+    }
+    catch(e){
+        if (e instanceof APIError){
+            return new Response(e.info.responseText,{status:e.info.status});
+        }
+        else{
+            throw e;
+        }
+    }
+}
+

src/app/api2/user/route.ts

@@ -0,0 +1,91 @@
+'use server'
+
+import { User, Auth, Post } from "@/model/sequelize/NewModels"
+import { APIError } from "@/api/error";
+import { UserAuth } from "@/api/user";
+import { hashPassword } from "@/util/Auth";
+
+
+
+async function tryRegister(request:Request){
+    
+    User.sync();
+
+    const requestBody:Partial<UserAuth> = await request.json();
+
+    if(!requestBody) throw new APIError({status:500,responseText: "Request Body is Empty"})
+    if(!requestBody.username) throw new APIError({status:500,responseText: "No username specified"})
+    if(!requestBody.password) throw new APIError({status:500,responseText: "No password specified"})
+    
+    const dbUser = await User.findOne({where:{username:requestBody.username}});
+
+    if(dbUser) throw new APIError({status:500,responseText: "Username unavailable, try another"});
+
+    const hash = await hashPassword(requestBody.password);
+    const user = await User.create({
+        username: requestBody.username,
+        password: hash
+    })
+    
+    return new Response(
+        JSON.stringify(
+        {
+            user: user
+        }),
+        { 
+            status: 200, 
+            headers:{
+                "Content-Type": "text/JSON" 
+            } 
+        }
+    ); 
+}
+
+export async function POST(request:Request){
+    try{
+        return await tryRegister(request);      
+    }
+    catch(e){
+        if (e instanceof APIError){
+            return new Response(e.info.responseText,{status:e.info.status});
+            console.log("responded")
+        }
+        else{
+            throw e;
+        }
+    }
+}
+
+async function tryGetUsers(request:Request){
+    
+    const users = await User.findAll({include: "authtokens"});
+
+
+    return new Response(
+        JSON.stringify(
+        {
+            users: users
+        }),
+        { 
+            status: 200, 
+            headers:{
+                "Content-Type": "text/JSON" 
+            } 
+        }
+    ); 
+}
+
+export async function GET(request:Request){
+    try{
+        return await tryGetUsers(request);      
+    }
+    catch(e){
+        if (e instanceof APIError){
+            return new Response(e.info.responseText,{status:e.info.status});
+            console.log("responded")
+        }
+        else{
+            throw e;
+        }
+    }
+}

src/app/article/[...slug]/page.tsx

@@ -7,20 +7,21 @@ import ArticlePreview from "@/components/news/article-preview"
 import ReactDOM from "react";
 import "public/global.css"
 import "@/app/index.css"
+import { Post, User } from "@/model/sequelize/NewModels";
+import { Attributes } from "sequelize";
 
 
-type Post = {
-    id: Number,
-    title: String,
-    content: String
-}
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
 
-async function getData(slug:String):Promise<Array<any>> {
+async function getData(slug:string):Promise<DeepPartial<Post>> {
     // Get all posts from the API
-    const res = await fetch(`http://localhost:3000/api/post/${slug}`);
+    const res = await fetch(`http://localhost:3000/api2/post/${slug}`);
     // The return value is *not* serialized
     // You can return Date, Map, Set, etc.
     // Recommendation: handle errors
+    console.log(res);
     if (!res.ok) {
         // This will activate the closest `error.js` Error Boundary
         throw new Error('Failed to fetch data');
@@ -28,11 +29,12 @@ async function getData(slug:String):Promise<Array<any>> {
     return res.json();
 }
 
-export default async function Page({ params }) {
+export default async function Page({ params }: {params: {slug:string}}) {
     const { slug } = params;
-    const post = ((await getData(slug))[0]);
+    const post:DeepPartial<Attributes<Post>> = await getData(slug);
     console.log(post);
 
+
     return <div className={`root`}>
         <Header />
         <Navbar />
@@ -44,7 +46,7 @@ export default async function Page({ params }) {
                 <ul><li>filter 1</li><li>filter 2</li><li>filter 3</li></ul>
             </Sidebar>
             <main>
-                <Article id={post.id} title={post.post.title} content={post.post.content}/>
+                <Article id={post?.id?.toString()} title={post?.title?.toString()} content={post?.content?.toString()}/>
             </main>
         </PageContainer>
     </div>;

src/app/page.tsx

@@ -6,9 +6,18 @@ import ArticlePreview   from "@/components/news/article-preview"
 import ReactDOM from "react";
 import "public/global.css"
 import "./index.css"
+import { Post } from "@/model/sequelize/NewModels";
+
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+
+export default async function Test() {
+
+    const response = await fetch("http://localhost:3000/api2/post/");
+    const articles:Array<DeepPartial<Post>> = await response.json();
 
 
-export default function Test() {
     return <div className={`root`}>
             <Header/>
             <Navbar/>
@@ -20,9 +29,11 @@ export default function Test() {
                     <ul><li>filter 1</li><li>filter 2</li><li>filter 3</li></ul>
                 </Sidebar>
                 <main>
-                    <ArticlePreview/>
-                    <ArticlePreview/>
-                    <ArticlePreview/>
+                    {articles.map((article, i) => {     
+                        console.log("Entered");                 
+                        // Return the element. Also pass key     
+                        return (<ArticlePreview id={article?.id?.toString()} content={article?.content} title={article?.title}></ArticlePreview>) 
+                    })}
                 </main>
             </PageContainer>
         </div>;