@kyro-cms/admin 0.1.6 → 0.1.8

package/src/pages/api/[collection]/[id]/versions.ts

@@ -0,0 +1,66 @@
+import type { APIRoute } from "astro";
+import { dataStore } from "@/lib/dataStore";
+
+export const GET: APIRoute = async ({ params, url }) => {
+  const { collection, id } = params;
+  if (!collection || !id) return new Response(null, { status: 400 });
+
+  try {
+    const compareA = url.searchParams.get("compareA");
+    const compareB = url.searchParams.get("compareB");
+
+    if (compareA && compareB) {
+      const diffs = await dataStore.compareVersions(
+        collection,
+        id,
+        isNaN(Number(compareA)) ? compareA : Number(compareA),
+        isNaN(Number(compareB)) ? compareB : Number(compareB),
+      );
+      return new Response(JSON.stringify({ diffs }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    const versions = await dataStore.findVersions(collection, id);
+    return new Response(JSON.stringify({ docs: versions }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    return new Response(JSON.stringify({ error: "Failed to fetch versions" }), {
+      status: 500,
+    });
+  }
+};
+
+export const POST: APIRoute = async ({ params, request }) => {
+  const { collection, id } = params;
+  if (!collection || !id) return new Response(null, { status: 400 });
+
+  try {
+    const { versionId, action } = await request.json();
+
+    if (action === "restore" && versionId) {
+      const restored = await dataStore.restoreVersion(
+        collection,
+        id,
+        versionId,
+      );
+      if (!restored)
+        return new Response(JSON.stringify({ error: "Restore failed" }), {
+          status: 400,
+        });
+      return new Response(JSON.stringify({ data: restored }), { status: 200 });
+    }
+
+    return new Response(JSON.stringify({ error: "Invalid action" }), {
+      status: 400,
+    });
+  } catch (error) {
+    return new Response(
+      JSON.stringify({ error: "Failed to perform version action" }),
+      { status: 500 },
+    );
+  }
+};

package/src/pages/api/[collection]/[id].ts

@@ -1,17 +1,14 @@
 import type { APIRoute } from "astro";
 import { dataStore } from "@/lib/dataStore";
 import { collections } from "@/lib/config";
+import { getAuthAdapter } from "../../../lib/db";
 
 dataStore.initialize(collections);
 
 const AUTH_COLLECTIONS = ["users", "roles", "audit_logs"];
 
-async function getAuthApi() {
-  const { RedisAuthAdapter } = await import("@kyro-cms/core");
-  return new RedisAuthAdapter({
-    url: process.env.REDIS_URL || "redis://localhost:6379",
-    tls: process.env.REDIS_TLS === "true",
-  });
+async function getAuthAdapterLocal() {
+  return await getAuthAdapter();
 }
 
 export const GET: APIRoute = async ({ params }) => {
@@ -19,76 +16,55 @@ export const GET: APIRoute = async ({ params }) => {
   const id = params.id as string;
 
   if (AUTH_COLLECTIONS.includes(collection)) {
-    try {
-      const adapter = await getAuthApi();
-      await adapter.connect();
+    const adapter = await getAuthAdapterLocal();
 
-      if (collection === "users") {
-        const user = await adapter.findUserById(id);
-        await adapter.disconnect();
-
-        if (!user) {
-          return new Response(JSON.stringify({ error: "User not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        const { passwordHash, ...safeUser } = user;
-        return new Response(JSON.stringify({ data: safeUser }), {
-          status: 200,
+    if (collection === "users") {
+      const user = await adapter.findUserById(id);
+      if (!user) {
+        return new Response(JSON.stringify({ error: "User not found" }), {
+          status: 404,
           headers: { "Content-Type": "application/json" },
         });
       }
+      const { passwordHash, ...safeUser } = user;
+      return new Response(JSON.stringify({ data: safeUser }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
 
-      if (collection === "audit_logs") {
-        const logData = await (adapter as any).redis.hgetall(
-          `kyro:auth:audit:${id}`,
-        );
-        await adapter.disconnect();
-
-        if (!logData || !logData.id) {
-          return new Response(JSON.stringify({ error: "Log not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        return new Response(
-          JSON.stringify({
-            data: {
-              id: logData.id,
-              action: logData.action,
-              userId: logData.userId,
-              userEmail: logData.userEmail,
-              role: logData.role,
-              resource: logData.resource,
-              ipAddress: logData.ipAddress,
-              success: logData.success === "true",
-              error: logData.error,
-              timestamp: logData.timestamp,
-            },
-          }),
-          { status: 200, headers: { "Content-Type": "application/json" } },
-        );
+    if (collection === "roles") {
+      const roles = await adapter.findUserRoles();
+      const role = roles.find((r) => r.id === id);
+      if (!role) {
+        return new Response(JSON.stringify({ error: "Role not found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" },
+        });
       }
-
-      await adapter.disconnect();
-    } catch (error) {
-      console.error(`Error fetching ${collection}:`, error);
-      return new Response(
-        JSON.stringify({ error: `Failed to fetch ${collection}` }),
-        { status: 500, headers: { "Content-Type": "application/json" } },
-      );
+      return new Response(JSON.stringify({ data: role }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
     }
+
+    return new Response(
+      JSON.stringify({ error: `Collection ${collection} not supported` }),
+      { status: 404, headers: { "Content-Type": "application/json" } },
+    );
   }
 
   try {
-    const doc = dataStore.findById(collection, id);
+    let doc = await dataStore.findById(collection, id);
+    if (!doc) {
+      const allDocs = (
+        await dataStore.find(collection, { page: 1, limit: 1000 })
+      ).docs;
+      doc = (allDocs || []).find((d: any) => d.slug === id) || null;
+    }
     if (!doc) {
       return new Response(JSON.stringify({ error: "Document not found" }), {
         status: 404,
-        headers: { "Content-Type": "application/json" },
       });
     }
     return new Response(JSON.stringify({ data: doc }), {
@@ -98,7 +74,6 @@ export const GET: APIRoute = async ({ params }) => {
   } catch (error) {
     return new Response(JSON.stringify({ error: "Failed to fetch document" }), {
       status: 500,
-      headers: { "Content-Type": "application/json" },
     });
   }
 };
@@ -108,77 +83,69 @@ export const PATCH: APIRoute = async ({ params, request }) => {
   const id = params.id as string;
 
   if (AUTH_COLLECTIONS.includes(collection)) {
-    try {
-      const adapter = await getAuthApi();
-      await adapter.connect();
-
-      const body = await request.json();
-
-      if (collection === "users") {
-        const existing = await adapter.findUserById(id);
-        if (!existing) {
-          await adapter.disconnect();
-          return new Response(JSON.stringify({ error: "User not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        const updateData: Record<string, unknown> = {};
-        if (body.email !== undefined) updateData.email = body.email;
-        if (body.role !== undefined) updateData.role = body.role;
-        if (body.tenantId !== undefined) updateData.tenantId = body.tenantId;
-        if (body.locked !== undefined) updateData.locked = body.locked;
-        if (body.emailVerified !== undefined)
-          updateData.emailVerified = body.emailVerified;
-
-        if (body.password) {
-          updateData.passwordHash = await adapter.hashPassword(body.password);
-        }
-
-        const user = await adapter.updateUser(id, updateData);
-        await adapter.disconnect();
-
-        if (!user) {
-          return new Response(
-            JSON.stringify({ error: "Failed to update user" }),
-            {
-              status: 500,
-              headers: { "Content-Type": "application/json" },
-            },
-          );
-        }
+    const adapter = await getAuthAdapterLocal();
+    const body = await request.json();
 
-        const { passwordHash, ...safeUser } = user;
-        return new Response(JSON.stringify({ data: safeUser }), {
-          status: 200,
+    if (collection === "users") {
+      const existing = await adapter.findUserById(id);
+      if (!existing) {
+        return new Response(JSON.stringify({ error: "User not found" }), {
+          status: 404,
           headers: { "Content-Type": "application/json" },
         });
       }
 
-      await adapter.disconnect();
-      return new Response(
-        JSON.stringify({
-          error: `Collection ${collection} does not support PATCH`,
-        }),
-        { status: 405, headers: { "Content-Type": "application/json" } },
-      );
-    } catch (error) {
-      console.error(`Error updating ${collection}:`, error);
-      return new Response(
-        JSON.stringify({ error: `Failed to update ${collection}` }),
-        { status: 500, headers: { "Content-Type": "application/json" } },
-      );
+      const updateData: Record<string, unknown> = {};
+      if (body.email !== undefined) updateData.email = body.email;
+      if (body.name !== undefined) updateData.name = body.name;
+      if (body.role !== undefined) updateData.role = body.role;
+      if (body.password) {
+        updateData.passwordHash = await adapter.hashPassword(body.password);
+      }
+
+      const user = await adapter.updateUser(id, updateData);
+      if (!user) {
+        return new Response(
+          JSON.stringify({ error: "Failed to update user" }),
+          {
+            status: 500,
+          },
+        );
+      }
+
+      const { passwordHash, ...safeUser } = user;
+      return new Response(JSON.stringify({ data: safeUser }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
     }
+
+    return new Response(
+      JSON.stringify({
+        error: `Collection ${collection} does not support PATCH`,
+      }),
+      { status: 405, headers: { "Content-Type": "application/json" } },
+    );
   }
 
   try {
     const body = await request.json();
-    const doc = dataStore.update(collection, id, body);
+    const versionStatus =
+      body.status === "draft"
+        ? "draft"
+        : body.status === "published"
+          ? "published"
+          : undefined;
+    const changeDescription = body._changeDescription;
+    const { _changeDescription, ...cleanBody } = body;
+
+    const doc = await dataStore.update(collection, id, cleanBody, {
+      versionStatus,
+      changeDescription,
+    });
     if (!doc) {
       return new Response(JSON.stringify({ error: "Document not found" }), {
         status: 404,
-        headers: { "Content-Type": "application/json" },
       });
     }
     return new Response(JSON.stringify({ data: doc }), {
@@ -188,7 +155,9 @@ export const PATCH: APIRoute = async ({ params, request }) => {
   } catch (error) {
     return new Response(
       JSON.stringify({ error: "Failed to update document" }),
-      { status: 500, headers: { "Content-Type": "application/json" } },
+      {
+        status: 500,
+      },
     );
   }
 };
@@ -198,51 +167,35 @@ export const DELETE: APIRoute = async ({ params }) => {
   const id = params.id as string;
 
   if (AUTH_COLLECTIONS.includes(collection)) {
-    try {
-      const adapter = await getAuthApi();
-      await adapter.connect();
-
-      if (collection === "users") {
-        const existing = await adapter.findUserById(id);
-        if (!existing) {
-          await adapter.disconnect();
-          return new Response(JSON.stringify({ error: "User not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
+    const adapter = await getAuthAdapterLocal();
 
-        await adapter.deleteUser(id);
-        await adapter.disconnect();
-
-        return new Response(JSON.stringify({ success: true }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
+    if (collection === "users") {
+      const existing = await adapter.findUserById(id);
+      if (!existing) {
+        return new Response(JSON.stringify({ error: "User not found" }), {
+          status: 404,
         });
       }
-
-      await adapter.disconnect();
-      return new Response(
-        JSON.stringify({
-          error: `Collection ${collection} does not support DELETE`,
-        }),
-        { status: 405, headers: { "Content-Type": "application/json" } },
-      );
-    } catch (error) {
-      console.error(`Error deleting ${collection}:`, error);
-      return new Response(
-        JSON.stringify({ error: `Failed to delete ${collection}` }),
-        { status: 500, headers: { "Content-Type": "application/json" } },
-      );
+      await adapter.deleteUser(id);
+      return new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
     }
+
+    return new Response(
+      JSON.stringify({
+        error: `Collection ${collection} does not support DELETE`,
+      }),
+      { status: 405, headers: { "Content-Type": "application/json" } },
+    );
   }
 
   try {
-    const success = dataStore.delete(collection, id);
+    const success = await dataStore.delete(collection, id);
     if (!success) {
       return new Response(JSON.stringify({ error: "Document not found" }), {
         status: 404,
-        headers: { "Content-Type": "application/json" },
       });
     }
     return new Response(JSON.stringify({ success: true }), {
@@ -252,7 +205,9 @@ export const DELETE: APIRoute = async ({ params }) => {
   } catch (error) {
     return new Response(
       JSON.stringify({ error: "Failed to delete document" }),
-      { status: 500, headers: { "Content-Type": "application/json" } },
+      {
+        status: 500,
+      },
     );
   }
 };