@devvistatech/devvista-kit 0.0.1

package/app/api/blog/route.ts

@@ -0,0 +1,307 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAuth } from "@clerk/nextjs/server";
+
+interface StrapiUser {
+  id: number;
+  username: string;
+  email: string;
+  businessAdminId?: string;
+  firstName?: string;
+  lastName?: string;
+}
+
+interface BlogPost {
+  id: number;
+  documentId: string;
+  title: string;
+  description: string;
+  author: string;
+  publishedAt: string;
+}
+
+const BLOG_API_URL = process.env.STRAPI_BLOG_API_URL || "http://localhost:1337/api/devvista-kit-blogs";
+const STRAPI_USER_LIST_API_URL = process.env.STRAPI_USER_LIST_API_URL || "http://localhost:1337/api/user-lists";
+const ADMIN_BUSINESS_ID = process.env.ADMIN_BUSINESS_ID || "DevVistaAdmin435313454";
+const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN || "";
+
+async function verifyUser(userId: string): Promise<StrapiUser | null> {
+  try {
+    const response = await fetch(
+      `${STRAPI_USER_LIST_API_URL}?filters[authId][$eq]=${userId}`,
+      {
+        headers: {
+          Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      console.error("User verification failed:", response.status);
+      return null;
+    }
+
+    const userData = await response.json();
+    const strapiUser = userData.data?.find((user: any) => user.authId === userId);
+    if (!strapiUser) return null;
+
+    return {
+      id: strapiUser.id,
+      username: strapiUser.username,
+      email: strapiUser.email,
+      businessAdminId: strapiUser.businessAdminId,
+      firstName: strapiUser.firstName,
+      lastName: strapiUser.lastName,
+    };
+  } catch (error) {
+    console.error("Error verifying user:", error);
+    return null;
+  }
+}
+
+async function getBlogPosts(userId: string | null, isAdmin: boolean): Promise<BlogPost[]> {
+  try {
+    // Fetch all blog posts for public users or admins; filter by userId for non-admin authenticated users
+    const url = userId && !isAdmin
+      ? `${BLOG_API_URL}?pagination[pageSize]=100&fields[0]=title&fields[1]=description&fields[2]=author&fields[3]=publishedAt&fields[4]=id&fields[5]=documentId&filters[authId][$eq]=${userId}`
+      : `${BLOG_API_URL}?pagination[pageSize]=100&fields[0]=title&fields[1]=description&fields[2]=author&fields[3]=publishedAt&fields[4]=id&fields[5]=documentId`;
+
+    const response = await fetch(url, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      cache: "no-store",
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to fetch blog posts: ${errorText}`);
+    }
+
+    const result = await response.json();
+    const blogPosts = (result.data || []).map((post: any) => ({
+      id: post.id || 0,
+      documentId: post.documentId || "",
+      title: post.attributes?.title || post.title || "",
+      description: post.attributes?.description || post.description || "",
+      author: post.attributes?.author || post.author || "",
+      publishedAt: post.attributes?.publishedAt ? new Date(post.attributes.publishedAt).toISOString() : new Date().toISOString(),
+    }));
+
+    return blogPosts.filter((post: BlogPost) => post.title && post.description);
+  } catch (error) {
+    console.error("Error fetching blog posts:", error);
+    throw error;
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    if (!BLOG_API_URL || !STRAPI_API_TOKEN) {
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { userId } = getAuth(request);
+    const user = userId ? await verifyUser(userId) : null;
+    const isAdmin = user ? user.businessAdminId === ADMIN_BUSINESS_ID : false;
+
+    // Allow public access (no userId) or authenticated users to fetch blog posts
+    const blogPosts = await getBlogPosts(userId, isAdmin);
+
+    return NextResponse.json({ data: { blogPosts } });
+  } catch (error) {
+    console.error("GET /api/blog: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while fetching blog posts" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(userId);
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID) {
+    return NextResponse.json({ error: "Unauthorized: Only admin can create blog posts" }, { status: 403 });
+  }
+
+  try {
+    if (!BLOG_API_URL || !STRAPI_API_TOKEN) {
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { data } = await request.json();
+    if (!data || !data.title || !data.description || !data.author) {
+      return NextResponse.json({ error: "Missing required fields" }, { status: 400 });
+    }
+
+    const response = await fetch(BLOG_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify({
+        data: {
+          title: data.title,
+          description: data.description,
+          author: data.author,
+          publishedAt: new Date().toISOString(),
+          authId: userId,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorData = {};
+      try {
+        errorData = JSON.parse(errorText);
+      } catch (parseError) {
+        console.error("Failed to parse Strapi response:", parseError);
+      }
+      return NextResponse.json(
+        { error: `Failed to create blog post: ${response.status} - ${JSON.stringify(errorData)}` },
+        { status: response.status }
+      );
+    }
+
+    const blogPosts = await getBlogPosts(userId, true);
+    return NextResponse.json({ data: { blogPosts } });
+  } catch (error) {
+    console.error("POST /api/blog: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while creating blog post" },
+      { status: 500 }
+    );
+  }
+}
+
+// api/blog.ts
+export async function PUT(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(userId);
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID) {
+    return NextResponse.json({ error: "Unauthorized: Only admin can update blog posts" }, { status: 403 });
+  }
+
+  try {
+    if (!BLOG_API_URL || !STRAPI_API_TOKEN) {
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { documentId, data } = await request.json();
+    if (!documentId || !data || !data.title || !data.description || !data.author) {
+      return NextResponse.json({ error: "Missing required fields or documentId" }, { status: 400 });
+    }
+
+    const response = await fetch(`${BLOG_API_URL}/${documentId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+      body: JSON.stringify({
+        data: {
+          title: data.title,
+          description: data.description,
+          author: data.author,
+          publishedAt: new Date().toISOString(),
+          authId: userId,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorData = {};
+      try {
+        errorData = JSON.parse(errorText);
+      } catch (parseError) {
+        console.error("Failed to parse Strapi response:", parseError);
+      }
+      return NextResponse.json(
+        { error: `Failed to update blog post: ${response.status} - ${JSON.stringify(errorData)}` },
+        { status: response.status }
+      );
+    }
+
+    const blogPosts = await getBlogPosts(userId, true);
+    return NextResponse.json({ data: { blogPosts } });
+  } catch (error) {
+    console.error("PUT /api/blog: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while updating blog post" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  const { userId } = getAuth(request);
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized: No user ID" }, { status: 401 });
+  }
+
+  const user = await verifyUser(userId);
+  if (!user || user.businessAdminId !== ADMIN_BUSINESS_ID) {
+    return NextResponse.json({ error: "Unauthorized: Only admin can delete blog posts" }, { status: 403 });
+  }
+
+  try {
+    if (!BLOG_API_URL || !STRAPI_API_TOKEN) {
+      return NextResponse.json(
+        { error: "Server configuration error: Missing required environment variables" },
+        { status: 500 }
+      );
+    }
+
+    const { documentId } = await request.json();
+    if (!documentId) {
+      return NextResponse.json({ error: "Missing documentId" }, { status: 400 });
+    }
+
+    const response = await fetch(`${BLOG_API_URL}/${documentId}`, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${STRAPI_API_TOKEN}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return NextResponse.json(
+        { error: `Failed to delete blog post: ${errorText}` },
+        { status: response.status }
+      );
+    }
+
+    const blogPosts = await getBlogPosts(userId, true);
+    return NextResponse.json({ data: { blogPosts } });
+  } catch (error) {
+    console.error("DELETE /api/blog: Error:", error);
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "An error occurred while deleting blog post" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/chat/route.ts

@@ -0,0 +1,15 @@
+import { openai } from "@ai-sdk/openai";
+import { streamText } from "ai";
+
+export const maxDuration = 30;
+
+export async function POST(req: Request) {
+  const { messages } = await req.json();
+
+  const result = await streamText({
+    model: openai("gpt-3.5-turbo"),
+    messages,
+  });
+
+  return result.toDataStreamResponse();
+}