studiocms 0.1.0-beta.10

package/dist/routes/rest/utils/auth-token.d.ts

@@ -0,0 +1,17 @@
+import type { APIContext } from 'astro';
+/**
+ * Verify the auth token
+ *
+ * Auth token is passed in the Authorization header as a Bearer token
+ * @example
+ * headers: {
+ * 	Authorization: 'Bearer <authToken>'
+ * }
+ * @param context The Astro API context
+ * @returns The user data if the auth token is valid, otherwise a 401 response
+ */
+export declare function verifyAuthToken(context: APIContext): Promise<Response | {
+    userId: string;
+    key: string;
+    rank: string;
+}>;

package/dist/routes/rest/utils/auth-token.js

@@ -0,0 +1,31 @@
+import { developerConfig } from "studiocms:config";
+import studioCMS_SDK from "studiocms:sdk";
+import { simpleResponse } from "../../../utils/simpleResponse.js";
+const { testingAndDemoMode } = developerConfig;
+const getAuthToken = (headerString) => {
+  if (!headerString) {
+    return null;
+  }
+  const parts = headerString.split(" ");
+  if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+    return null;
+  }
+  return parts[1];
+};
+async function verifyAuthToken(context) {
+  if (testingAndDemoMode) {
+    return simpleResponse(400, "Testing and demo mode is enabled, this action is disabled.");
+  }
+  const authToken = getAuthToken(context.request.headers.get("Authorization"));
+  if (!authToken) {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const user = await studioCMS_SDK.REST_API.tokens.verify(authToken);
+  if (!user) {
+    return simpleResponse(401, "Unauthorized");
+  }
+  return user;
+}
+export {
+  verifyAuthToken
+};

package/dist/routes/rest/v1/folders/[id].d.ts

@@ -0,0 +1,6 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const PATCH: APIRoute;
+export declare const DELETE: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/rest/v1/folders/[id].js

@@ -0,0 +1,106 @@
+import studioCMS_SDK from "studiocms:sdk";
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+import { simpleResponse } from "../../../../utils/simpleResponse.js";
+import { verifyAuthToken } from "../../utils/auth-token.js";
+const GET = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid folder ID");
+  }
+  const folder = await studioCMS_SDK_Cache.GET.folder(id);
+  if (!folder) {
+    return simpleResponse(404, "Folder not found");
+  }
+  return new Response(JSON.stringify(folder), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+const PATCH = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid folder ID");
+  }
+  const jsonData = await context.request.json();
+  const { folderName, parentFolder } = jsonData;
+  if (!folderName) {
+    return simpleResponse(400, "Invalid form data, folderName is required");
+  }
+  try {
+    await studioCMS_SDK_Cache.UPDATE.folder({
+      id,
+      name: folderName,
+      parent: parentFolder || null
+    });
+    return simpleResponse(200, "Folder updated successfully");
+  } catch (error) {
+    return simpleResponse(500, "Failed to update folder");
+  }
+};
+const DELETE = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid folder ID");
+  }
+  try {
+    await studioCMS_SDK.DELETE.folder(id);
+    await studioCMS_SDK_Cache.UPDATE.folderList();
+    await studioCMS_SDK_Cache.UPDATE.folderTree();
+    return simpleResponse(200, "Folder deleted successfully");
+  } catch (error) {
+    return simpleResponse(500, "Failed to delete folder");
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET, PATCH, DELETE",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  DELETE,
+  GET,
+  OPTIONS,
+  PATCH
+};

package/dist/routes/rest/v1/folders/index.d.ts

@@ -0,0 +1,5 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/rest/v1/folders/index.js

@@ -0,0 +1,88 @@
+import studioCMS_SDK from "studiocms:sdk";
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+import { simpleResponse } from "../../../../utils/simpleResponse.js";
+import { verifyAuthToken } from "../../utils/auth-token.js";
+const GET = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const folders = await studioCMS_SDK_Cache.GET.folderList();
+  const searchParams = context.url.searchParams;
+  const folderNameFilter = searchParams.get("name");
+  const folderParentFilter = searchParams.get("parent");
+  let filteredFolders = folders.data;
+  if (folderNameFilter) {
+    filteredFolders = filteredFolders.filter((folder) => folder.name.includes(folderNameFilter));
+  }
+  if (folderParentFilter) {
+    filteredFolders = filteredFolders.filter((folder) => folder.parent === folderParentFilter);
+  }
+  const finalFolders = {
+    data: filteredFolders,
+    lastCacheUpdate: folders.lastCacheUpdate
+  };
+  return new Response(JSON.stringify(finalFolders), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+const POST = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const jsonData = await context.request.json();
+  const { folderName, parentFolder } = jsonData;
+  if (!folderName) {
+    return simpleResponse(400, "Invalid form data, folderName is required");
+  }
+  try {
+    const newFolder = (await studioCMS_SDK.POST.databaseEntry.folder({
+      name: folderName,
+      parent: parentFolder || null,
+      id: crypto.randomUUID()
+    }))[0];
+    await studioCMS_SDK_Cache.UPDATE.folderList();
+    await studioCMS_SDK_Cache.UPDATE.folderTree();
+    return simpleResponse(200, `Folder created successfully with id: ${newFolder.id}`);
+  } catch (error) {
+    return simpleResponse(500, "Failed to create folder");
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET, POST",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS,
+  POST
+};

package/dist/routes/rest/v1/pages/[id]/history/[diffid].d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/rest/v1/pages/[id]/history/[diffid].js

@@ -0,0 +1,55 @@
+import studioCMS_SDK from "studiocms:sdk";
+import { simpleResponse } from "../../../../../../utils/simpleResponse.js";
+import { verifyAuthToken } from "../../../../utils/auth-token.js";
+const GET = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id, diffid } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid page ID");
+  }
+  if (!diffid) {
+    return simpleResponse(400, "Invalid diff ID");
+  }
+  const diff = await studioCMS_SDK.diffTracking.get.withHtml(diffid);
+  if (!diff) {
+    return simpleResponse(404, "Diff not found");
+  }
+  return new Response(JSON.stringify(diff), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/rest/v1/pages/[id]/history/index.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/rest/v1/pages/[id]/history/index.js

@@ -0,0 +1,61 @@
+import studioCMS_SDK from "studiocms:sdk";
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+import { simpleResponse } from "../../../../../../utils/simpleResponse.js";
+import { verifyAuthToken } from "../../../../utils/auth-token.js";
+const GET = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid page ID");
+  }
+  const page = await studioCMS_SDK_Cache.GET.page.byId(id);
+  if (!page) {
+    return simpleResponse(404, "Page not found");
+  }
+  const searchParams = context.url.searchParams;
+  const limit = searchParams.get("limit");
+  let diffs = [];
+  if (limit) {
+    diffs = await studioCMS_SDK.diffTracking.get.byPageId.latest(id, Number.parseInt(limit));
+  } else {
+    diffs = await studioCMS_SDK.diffTracking.get.byPageId.all(id);
+  }
+  return new Response(JSON.stringify(diffs), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/rest/v1/pages/[id]/index.d.ts

@@ -0,0 +1,6 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const PATCH: APIRoute;
+export declare const DELETE: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/rest/v1/pages/[id]/index.js

@@ -0,0 +1,165 @@
+import studioCMS_SDK from "studiocms:sdk";
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+import { simpleResponse } from "../../../../../utils/simpleResponse.js";
+import { verifyAuthToken } from "../../../utils/auth-token.js";
+const GET = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid page ID");
+  }
+  const page = await studioCMS_SDK_Cache.GET.page.byId(id);
+  if (!page) {
+    return simpleResponse(404, "Page not found");
+  }
+  return new Response(JSON.stringify(page), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+const PATCH = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank, userId } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid page ID");
+  }
+  const jsonData = await context.request.json();
+  const { data, content } = jsonData;
+  if (!data) {
+    return simpleResponse(400, "Invalid form data, data is required");
+  }
+  if (!content) {
+    return simpleResponse(400, "Invalid form data, content is required");
+  }
+  if (!data.id) {
+    return simpleResponse(400, "Invalid form data, id is required");
+  }
+  if (!content.id) {
+    return simpleResponse(400, "Invalid form data, id is required");
+  }
+  const currentPageData = await studioCMS_SDK_Cache.GET.page.byId(id);
+  if (!currentPageData) {
+    return simpleResponse(404, "Page not found");
+  }
+  const { authorId, contributorIds } = currentPageData.data;
+  let AuthorId = authorId;
+  if (!authorId) {
+    AuthorId = userId || null;
+  }
+  const ContributorIds = contributorIds || [];
+  if (!ContributorIds.includes(userId)) {
+    ContributorIds.push(userId);
+  }
+  data.authorId = AuthorId;
+  data.contributorIds = JSON.stringify(ContributorIds);
+  data.updatedAt = /* @__PURE__ */ new Date();
+  const startMetaData = (await studioCMS_SDK.GET.databaseTable.pageData()).find(
+    (metaData) => metaData.id === data.id
+  );
+  const {
+    data: { defaultContent }
+  } = await studioCMS_SDK_Cache.GET.page.byId(data.id);
+  try {
+    await studioCMS_SDK_Cache.UPDATE.page.byId(data.id, {
+      pageData: data,
+      pageContent: content
+    });
+    const updatedMetaData = (await studioCMS_SDK.GET.databaseTable.pageData()).find(
+      (metaData) => metaData.id === data.id
+    );
+    const { enableDiffs, diffPerPage } = (await studioCMS_SDK_Cache.GET.siteConfig()).data;
+    if (enableDiffs) {
+      await studioCMS_SDK.diffTracking.insert(
+        userId,
+        data.id,
+        {
+          content: {
+            start: defaultContent?.content || "",
+            end: content.content || ""
+          },
+          // biome-ignore lint/style/noNonNullAssertion: <explanation>
+          metaData: { start: startMetaData, end: updatedMetaData }
+        },
+        diffPerPage
+      );
+    }
+    studioCMS_SDK_Cache.CLEAR.page.byId(id);
+    return simpleResponse(200, "Page updated successfully");
+  } catch (error) {
+    console.error(error);
+    return simpleResponse(500, "Failed to update page");
+  }
+};
+const DELETE = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const { id } = context.params;
+  if (!id) {
+    return simpleResponse(400, "Invalid page ID");
+  }
+  const jsonData = await context.request.json();
+  const { slug } = jsonData;
+  if (!slug) {
+    return simpleResponse(400, "Invalid request");
+  }
+  const isHomePage = await studioCMS_SDK_Cache.GET.page.bySlug("index");
+  if (isHomePage.data && isHomePage.data.id === id) {
+    return simpleResponse(400, "Cannot delete home page");
+  }
+  try {
+    await studioCMS_SDK.DELETE.page(id);
+    studioCMS_SDK_Cache.CLEAR.page.byId(id);
+    return simpleResponse(200, "Page deleted successfully");
+  } catch (error) {
+    return simpleResponse(500, "Failed to delete page");
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET, PATCH, DELETE",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  DELETE,
+  GET,
+  OPTIONS,
+  PATCH
+};

package/dist/routes/rest/v1/pages/index.d.ts

@@ -0,0 +1,5 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/rest/v1/pages/index.js

@@ -0,0 +1,113 @@
+import studioCMS_SDK from "studiocms:sdk";
+import studioCMS_SDK_Cache from "studiocms:sdk/cache";
+import { simpleResponse } from "../../../../utils/simpleResponse.js";
+import { verifyAuthToken } from "../../utils/auth-token.js";
+const GET = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const pages = await studioCMS_SDK_Cache.GET.pages(true);
+  const searchParams = context.url.searchParams;
+  const titleFilter = searchParams.get("title");
+  const slugFilter = searchParams.get("slug");
+  const authorFilter = searchParams.get("author");
+  const draftFilter = searchParams.get("draft") === "true";
+  const publishedFilter = searchParams.get("published") === "true";
+  const parentFolderFilter = searchParams.get("parentFolder");
+  let filteredPages = pages;
+  if (titleFilter) {
+    filteredPages = filteredPages.filter((page) => page.data.title.includes(titleFilter));
+  }
+  if (slugFilter) {
+    filteredPages = filteredPages.filter((page) => page.data.slug.includes(slugFilter));
+  }
+  if (authorFilter) {
+    filteredPages = filteredPages.filter((page) => page.data.authorId === authorFilter);
+  }
+  if (draftFilter) {
+    filteredPages = filteredPages.filter((page) => page.data.draft === draftFilter);
+  }
+  if (publishedFilter) {
+    filteredPages = filteredPages.filter((page) => !page.data.draft);
+  }
+  if (parentFolderFilter) {
+    filteredPages = filteredPages.filter((page) => page.data.parentFolder === parentFolderFilter);
+  }
+  return new Response(JSON.stringify(filteredPages), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+const POST = async (context) => {
+  const user = await verifyAuthToken(context);
+  if (user instanceof Response) {
+    return user;
+  }
+  const { rank, userId } = user;
+  if (rank !== "owner" && rank !== "admin" && rank !== "editor") {
+    return simpleResponse(401, "Unauthorized");
+  }
+  const jsonData = await context.request.json();
+  const { data, content } = jsonData;
+  if (!data) {
+    return simpleResponse(400, "Invalid form data, data is required");
+  }
+  if (!content) {
+    return simpleResponse(400, "Invalid form data, content is required");
+  }
+  if (!data.title) {
+    return simpleResponse(400, "Invalid form data, title is required");
+  }
+  const dataId = crypto.randomUUID();
+  const contentId = crypto.randomUUID();
+  try {
+    await studioCMS_SDK.POST.databaseEntry.pages(
+      {
+        id: dataId,
+        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+        title: data.title,
+        slug: data.slug || data.title.toLowerCase().replace(/\s/g, "-"),
+        description: data.description || "",
+        authorId: userId || null,
+        ...data
+      },
+      { id: contentId, ...content }
+    );
+    return simpleResponse(200, `Page created successfully with id: ${dataId}`);
+  } catch (error) {
+    return simpleResponse(500, "Internal Server Error");
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET, POST",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS,
+  POST
+};

package/dist/routes/rest/v1/public/folders/[id].d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;