studiocms 0.1.0-beta.10

package/dist/sdk/core.js

@@ -0,0 +1,1966 @@
+import { createTwoFilesPatch } from "diff";
+import { html } from "diff2html";
+import { and, asc, desc, eq } from "drizzle-orm";
+import { CMSSiteConfigId, GhostUserDefaults } from "../consts.js";
+import { StudioCMS_SDK_Error } from "./errors.js";
+import {
+  addPageToFolderTree,
+  findNodeById,
+  findNodeByPath,
+  findNodesAlongPath,
+  findNodesAlongPathToId,
+  generateFolderTree,
+  getFullPath
+} from "./lib/foldertree.js";
+import {
+  generateRandomIDNumber,
+  generateRandomPassword,
+  generateToken,
+  testToken
+} from "./lib/generators.js";
+import { parseIdNumberArray, parseIdStringArray } from "./lib/parsers.js";
+import { combineRanks, verifyRank } from "./lib/users.js";
+import {
+  tsAPIKeys,
+  tsDiffTracking,
+  tsOAuthAccounts,
+  tsPageContent,
+  tsPageData,
+  tsPageDataCategories,
+  tsPageDataTags,
+  tsPageFolderStructure,
+  tsPermissions,
+  tsSessionTable,
+  tsSiteConfig,
+  tsUserResetTokens,
+  tsUsers
+} from "./tables.js";
+import { useDB } from "./utils/db.js";
+const db = useDB();
+function studiocmsSDKCore() {
+  async function buildFolderTree() {
+    const currentFolders = await db.select().from(tsPageFolderStructure);
+    return generateFolderTree(currentFolders);
+  }
+  async function getAvailableFolders() {
+    const folders = [];
+    const currentFolders = await db.select().from(tsPageFolderStructure);
+    for (const current of currentFolders) {
+      folders.push(current);
+    }
+    return folders;
+  }
+  async function clearUserReferences(userId) {
+    try {
+      await db.batch([
+        db.delete(tsUserResetTokens).where(eq(tsUserResetTokens.userId, userId)),
+        db.delete(tsPermissions).where(eq(tsPermissions.user, userId)),
+        db.delete(tsOAuthAccounts).where(eq(tsOAuthAccounts.userId, userId)),
+        db.delete(tsSessionTable).where(eq(tsSessionTable.userId, userId)),
+        db.update(tsDiffTracking).set({ userId: GhostUserDefaults.id }).where(eq(tsDiffTracking.userId, userId)),
+        db.update(tsPageData).set({ authorId: GhostUserDefaults.id }).where(eq(tsPageData.authorId, userId))
+      ]);
+      return true;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StudioCMS_SDK_Error(
+          `Error clearing user references: ${error.message}`,
+          error.stack
+        );
+      }
+      throw new StudioCMS_SDK_Error("Error clearing user references: An unknown error occurred.");
+    }
+  }
+  async function collectCategories(categoryIds) {
+    try {
+      const categories = [];
+      if (categoryIds.length > 0) {
+        const [categoryHead, ...categoryTail] = categoryIds.map(
+          (id) => db.select().from(tsPageDataCategories).where(eq(tsPageDataCategories.id, id))
+        );
+        if (categoryHead) {
+          const categoryResults = await db.batch([categoryHead, ...categoryTail]);
+          categories.push(...categoryResults.flat().filter((result) => result !== void 0));
+        }
+      }
+      return categories;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StudioCMS_SDK_Error(`Error getting categories: ${error.message}`, error.stack);
+      }
+      throw new StudioCMS_SDK_Error("Error getting categories: An unknown error occurred.");
+    }
+  }
+  async function collectTags(tagIds) {
+    try {
+      const tags = [];
+      const [tagHead, ...tagTail] = tagIds.map(
+        (id) => db.select().from(tsPageDataTags).where(eq(tsPageDataTags.id, id))
+      );
+      if (tagHead) {
+        const tagResults = await db.batch([tagHead, ...tagTail]);
+        tags.push(...tagResults.flat().filter((result) => result !== void 0));
+      }
+      return tags;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StudioCMS_SDK_Error(`Error getting tags: ${error.message}`, error.stack);
+      }
+      throw new StudioCMS_SDK_Error("Error getting tags: An unknown error occurred.");
+    }
+  }
+  async function collectPageData(page, tree) {
+    try {
+      const categoryIds = parseIdNumberArray(page.categories || []);
+      const categories = await collectCategories(categoryIds);
+      const tagIds = parseIdNumberArray(page.tags || []);
+      const tags = await collectTags(tagIds);
+      const contributorIds = parseIdStringArray(page.contributorIds || []);
+      const multiLanguageContentData = await db.select().from(tsPageContent).where(eq(tsPageContent.contentId, page.id));
+      const defaultLanguageContentData = multiLanguageContentData.find(
+        (content) => content.contentLang === page.contentLang
+      );
+      const safeSlug = page.slug === "index" ? "/" : `/${page.slug}`;
+      let urlRoute = safeSlug;
+      if (page.parentFolder) {
+        const urlParts = findNodesAlongPathToId(tree, page.parentFolder);
+        urlRoute = urlParts.map((part) => part.name).join("/") + safeSlug;
+      }
+      return {
+        ...page,
+        urlRoute,
+        categories,
+        tags,
+        contributorIds,
+        multiLangContent: multiLanguageContentData,
+        defaultContent: defaultLanguageContentData
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StudioCMS_SDK_Error(`Error collecting page data: ${error.message}`, error.stack);
+      }
+      throw new StudioCMS_SDK_Error("Error collecting page data: An unknown error occurred.");
+    }
+  }
+  async function collectUserData(user) {
+    try {
+      const [oAuthData, permissionData] = await db.batch([
+        db.select().from(tsOAuthAccounts).where(eq(tsOAuthAccounts.userId, user.id)),
+        db.select().from(tsPermissions).where(eq(tsPermissions.user, user.id))
+      ]);
+      return {
+        ...user,
+        oAuthData,
+        permissionsData: permissionData[0]
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StudioCMS_SDK_Error(`Error collecting user data: ${error.message}`, error.stack);
+      }
+      throw new StudioCMS_SDK_Error("Error collecting user data: An unknown error occurred.");
+    }
+  }
+  const resetTokenBucket = {
+    new: async (userId) => {
+      const token = generateToken(userId);
+      return await db.insert(tsUserResetTokens).values({ id: crypto.randomUUID(), userId, token }).returning().get();
+    },
+    delete: async (userId) => {
+      await db.delete(tsUserResetTokens).where(eq(tsUserResetTokens.userId, userId));
+    },
+    check: async (token) => {
+      const _token = testToken(token);
+      const resetToken = await db.select().from(tsUserResetTokens).where(eq(tsUserResetTokens.userId, _token.userId)).get();
+      if (!resetToken) {
+        return false;
+      }
+      return resetToken.token === token;
+    }
+  };
+  async function checkDiffsLengthAndRemoveOldestIfToLong(pageId, length) {
+    const diffs = await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.pageId, pageId)).orderBy(asc(tsDiffTracking.timestamp));
+    if (diffs.length > length) {
+      const oldestDiff = diffs[0];
+      await db.delete(tsDiffTracking).where(eq(tsDiffTracking.id, oldestDiff.id));
+    }
+  }
+  const REST_API = {
+    tokens: {
+      get: async (userId) => {
+        return await db.select().from(tsAPIKeys).where(eq(tsAPIKeys.userId, userId));
+      },
+      new: async (userId, description) => {
+        const key = generateToken(userId);
+        return await db.insert(tsAPIKeys).values({
+          id: crypto.randomUUID(),
+          creationDate: /* @__PURE__ */ new Date(),
+          userId,
+          key,
+          description
+        }).returning().get();
+      },
+      delete: async (userId, tokenId) => {
+        await db.delete(tsAPIKeys).where(and(eq(tsAPIKeys.userId, userId), eq(tsAPIKeys.id, tokenId)));
+      },
+      verify: async (key) => {
+        const apiKey = await db.select().from(tsAPIKeys).where(eq(tsAPIKeys.key, key)).get();
+        if (!apiKey) {
+          return false;
+        }
+        const keyRank = await db.select().from(tsPermissions).where(eq(tsPermissions.user, apiKey.userId)).get();
+        if (!keyRank) {
+          return false;
+        }
+        return {
+          userId: apiKey.userId,
+          key: apiKey.key,
+          rank: keyRank.rank
+        };
+      }
+    }
+  };
+  const diffTracking = {
+    insert: async (userId, pageId, data, diffLength) => {
+      const diff = createTwoFilesPatch("Content", "Content", data.content.start, data.content.end);
+      await checkDiffsLengthAndRemoveOldestIfToLong(pageId, diffLength);
+      return await db.insert(tsDiffTracking).values({
+        id: crypto.randomUUID(),
+        userId,
+        pageId,
+        diff,
+        timestamp: /* @__PURE__ */ new Date(),
+        pageContentStart: data.content.start,
+        pageMetaData: JSON.stringify(data.metaData)
+      }).returning().get();
+    },
+    clear: async (pageId) => {
+      await db.delete(tsDiffTracking).where(eq(tsDiffTracking.pageId, pageId));
+    },
+    get: {
+      byPageId: {
+        all: async (pageId) => {
+          return await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.pageId, pageId)).orderBy(desc(tsDiffTracking.timestamp));
+        },
+        latest: async (pageId, count) => {
+          const diffs = await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.pageId, pageId)).orderBy(desc(tsDiffTracking.timestamp));
+          return diffs.slice(0, count);
+        }
+      },
+      byUserId: {
+        all: async (userId) => {
+          return await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.userId, userId)).orderBy(desc(tsDiffTracking.timestamp));
+        },
+        latest: async (userId, count) => {
+          const diffs = await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.userId, userId)).orderBy(desc(tsDiffTracking.timestamp));
+          return diffs.slice(0, count);
+        }
+      },
+      single: async (id) => {
+        return await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.id, id)).get();
+      },
+      withHtml: async (id, options) => {
+        const diffEntry = await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.id, id)).get();
+        if (!diffEntry) {
+          throw new StudioCMS_SDK_Error("Diff not found");
+        }
+        if (!diffEntry.diff) {
+          throw new StudioCMS_SDK_Error("Diff not found");
+        }
+        const contentDiffHtml = html(diffEntry.diff, {
+          diffStyle: "word",
+          matching: "lines",
+          drawFileList: false,
+          outputFormat: "side-by-side",
+          ...options
+        });
+        const diff = createTwoFilesPatch(
+          "Metadata",
+          "Metadata",
+          JSON.stringify(JSON.parse(diffEntry.pageMetaData).start, null, 2),
+          JSON.stringify(JSON.parse(diffEntry.pageMetaData).end, null, 2)
+        );
+        const metadataDiffHtml = html(diff, {
+          diffStyle: "word",
+          matching: "lines",
+          drawFileList: false,
+          outputFormat: "side-by-side",
+          ...options
+        });
+        return {
+          ...diffEntry,
+          metadataDiffHtml,
+          contentDiffHtml
+        };
+      }
+    },
+    revertToDiff: async (id, type) => {
+      const diffEntry = await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.id, id)).get();
+      if (!diffEntry) {
+        throw new StudioCMS_SDK_Error("Diff not found");
+      }
+      const shouldRevertData = type === "data" || type === "both";
+      const shouldRevertContent = type === "content" || type === "both";
+      if (shouldRevertData) {
+        const pageData = JSON.parse(diffEntry.pageMetaData);
+        await db.update(tsPageData).set(pageData.start).where(eq(tsPageData.id, pageData.end.id));
+      }
+      if (shouldRevertContent) {
+        await db.update(tsPageContent).set({ content: diffEntry.pageContentStart }).where(eq(tsPageContent.contentId, diffEntry.pageId));
+      }
+      const allDiffs = await db.select().from(tsDiffTracking).where(eq(tsDiffTracking.pageId, diffEntry.pageId)).orderBy(desc(tsDiffTracking.timestamp));
+      const diffIndex = allDiffs.findIndex((diff) => diff.id === id);
+      const diffsToPurge = allDiffs.slice(diffIndex + 1);
+      for (const diff of diffsToPurge) {
+        await db.delete(tsDiffTracking).where(eq(tsDiffTracking.id, diff.id));
+      }
+      return diffEntry;
+    }
+  };
+  const AUTH = {
+    /**
+     * Provides various methods to create, delete, and search for OAuth accounts in the StudioCMS database.
+     */
+    oAuth: {
+      /**
+       * Creates a new OAuth account in the database.
+       *
+       * @param data - The data to insert into the OAuth account table.
+       * @returns A promise that resolves to the inserted OAuth account.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while creating the OAuth account.
+       */
+      create: async (data) => {
+        try {
+          return await db.insert(tsOAuthAccounts).values(data).returning().get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error creating OAuth account: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error creating OAuth account: An unknown error occurred.");
+        }
+      },
+      /**
+       * Deletes an OAuth account from the database.
+       *
+       * @param userId - The ID of the user associated with the OAuth account.
+       * @param provider - The provider of the OAuth account.
+       * @returns A promise that resolves to a deletion response.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the OAuth account.
+       */
+      delete: async (userId, provider) => {
+        try {
+          return await db.delete(tsOAuthAccounts).where(and(eq(tsOAuthAccounts.userId, userId), eq(tsOAuthAccounts.provider, provider))).then(() => {
+            return {
+              status: "success",
+              message: "OAuth account deleted"
+            };
+          });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error deleting OAuth account: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error deleting OAuth account: An unknown error occurred.");
+        }
+      },
+      /**
+       * Searches for OAuth accounts based on the provider ID and user ID.
+       *
+       * @param providerId - The provider ID to search for.
+       * @param userId - The user ID to search for.
+       * @returns A promise that resolves to the OAuth account data if found, otherwise undefined.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while searching for the OAuth account.
+       */
+      searchProvidersForId: async (providerId, userId) => {
+        try {
+          return await db.select().from(tsOAuthAccounts).where(
+            and(
+              eq(tsOAuthAccounts.providerUserId, providerId),
+              eq(tsOAuthAccounts.userId, userId)
+            )
+          ).get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error searching for OAuth account: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error(
+            "Error searching for OAuth account: An unknown error occurred."
+          );
+        }
+      }
+    },
+    /**
+     * Provides various methods to get and update permissions for users in the StudioCMS database.
+     */
+    permission: {
+      /**
+       * Checks the current status of a user's permissions.
+       */
+      currentStatus: async (userId) => {
+        try {
+          return await db.select().from(tsPermissions).where(eq(tsPermissions.user, userId)).get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error getting user permissions: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error(
+            "Error getting user permissions: An unknown error occurred."
+          );
+        }
+      }
+    },
+    /**
+     * Provides various methods to create, delete, and update sessions in the StudioCMS database.
+     */
+    session: {
+      /**
+       * Creates a new session in the database.
+       *
+       * @param data - The data to insert into the session table.
+       * @returns A promise that resolves to the inserted session.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while creating the session.
+       */
+      create: async (data) => {
+        try {
+          return await db.insert(tsSessionTable).values(data).returning({
+            id: tsSessionTable.id,
+            userId: tsSessionTable.userId,
+            expiresAt: tsSessionTable.expiresAt
+          }).get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error creating session: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error creating session: An unknown error occurred.");
+        }
+      },
+      /**
+       * Gets a session with the associated user.
+       *
+       * @param sessionId - The ID of the session to search for.
+       * @returns A promise that resolves to the session with the associated user.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the session with the user.
+       */
+      sessionWithUser: async (sessionId) => {
+        try {
+          return await db.select({ user: tsUsers, session: tsSessionTable }).from(tsSessionTable).innerJoin(tsUsers, eq(tsSessionTable.userId, tsUsers.id)).where(eq(tsSessionTable.id, sessionId));
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error getting session with user: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error(
+            "Error getting session with user: An unknown error occurred."
+          );
+        }
+      },
+      /**
+       * Deletes a session from the database.
+       *
+       * @param sessionId - The ID of the session to delete.
+       * @returns A promise that resolves to a deletion response.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the session.
+       */
+      delete: async (sessionId) => {
+        try {
+          await db.delete(tsSessionTable).where(eq(tsSessionTable.id, sessionId));
+          return {
+            status: "success",
+            message: "Session deleted"
+          };
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error deleting session: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error deleting session: An unknown error occurred.");
+        }
+      },
+      /**
+       * Updates the expiration date of a session.
+       *
+       * @param sessionId - The ID of the session to update.
+       * @param newDate - The new expiration date for the session.
+       * @returns A promise that resolves to the updated session.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while updating the session.
+       */
+      update: async (sessionId, newDate) => {
+        try {
+          return await db.update(tsSessionTable).set({ expiresAt: newDate }).where(eq(tsSessionTable.id, sessionId)).returning();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error updating session: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error updating session: An unknown error occurred.");
+        }
+      }
+    },
+    /**
+     * Provides various methods to create, update, and search for users in the StudioCMS database.
+     */
+    user: {
+      /**
+       * Creates a new user in the database.
+       *
+       * @param newUserData - The data to insert into the users table.
+       * @returns A promise that resolves to the inserted user.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while creating the user.
+       */
+      create: async (newUserData, rank) => {
+        try {
+          const newUser = await db.insert(tsUsers).values(newUserData).returning().get();
+          await db.insert(tsPermissions).values({ user: newUser.id, rank: rank || "visitor" });
+          return newUser;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error creating user: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error creating user: An unknown error occurred.");
+        }
+      },
+      /**
+       * Updates a user in the database.
+       *
+       * @param userId - The ID of the user to update.
+       * @param userData - The data to update the user with.
+       * @returns A promise that resolves to the updated user.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while updating the user.
+       */
+      update: async (userId, userData) => {
+        try {
+          return await db.update(tsUsers).set(userData).where(eq(tsUsers.id, userId)).returning().get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error updating user: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error updating user: An unknown error occurred.");
+        }
+      },
+      /**
+       * Searches for users based on the provided username or email.
+       *
+       * @param username - The username to search for.
+       * @param email - The email to search for.
+       * @returns A promise that resolves to an object containing the search results for the username and email.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while searching for the username or email.
+       */
+      searchUsersForUsernameOrEmail: async (username, email) => {
+        try {
+          const [usernameSearch, emailSearch] = await db.batch([
+            db.select().from(tsUsers).where(eq(tsUsers.username, username)),
+            db.select().from(tsUsers).where(eq(tsUsers.email, email))
+          ]);
+          return { usernameSearch, emailSearch };
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error searching for username or email: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error(
+            "Error searching for username or email: An unknown error occurred."
+          );
+        }
+      },
+      /**
+       * Ghost user utilities.
+       */
+      ghost: {
+        /**
+         * Verifies if the ghost user exists in the database.
+         *
+         * @returns A promise that resolves to a boolean indicating if the ghost user exists.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while verifying the ghost user.
+         */
+        verifyExists: async () => {
+          try {
+            const ghostUser = await db.select().from(tsUsers).where(eq(tsUsers.id, GhostUserDefaults.id)).get();
+            if (!ghostUser) {
+              return false;
+            }
+            return true;
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error verifying ghost user exists: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error(
+              "Error verifying ghost user exists: An unknown error occurred."
+            );
+          }
+        },
+        /**
+         * Creates the ghost user in the database.
+         *
+         * @returns A promise that resolves to the inserted ghost user.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while creating the ghost user.
+         */
+        create: async () => {
+          try {
+            return await db.insert(tsUsers).values(GhostUserDefaults).returning().get();
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error creating ghost user: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error("Error creating ghost user: An unknown error occurred.");
+          }
+        },
+        /**
+         * Gets the ghost user from the database.
+         *
+         * @returns A promise that resolves to the ghost user.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while getting the ghost user.
+         */
+        get: async () => {
+          try {
+            return await db.select().from(tsUsers).where(eq(tsUsers.id, GhostUserDefaults.id)).get();
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error getting ghost user: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error("Error getting ghost user: An unknown error occurred.");
+          }
+        }
+      }
+    }
+  };
+  const INIT = {
+    /**
+     * Initializes the StudioCMS SiteConfig table with the provided configuration.
+     *
+     * @param config - The configuration to insert into the SiteConfig table.
+     * @returns A promise that resolves to the inserted site configuration.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while creating the site configuration.
+     */
+    siteConfig: async (config) => {
+      try {
+        return await db.insert(tsSiteConfig).values({ ...config, id: CMSSiteConfigId }).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error creating site configuration: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          "Error creating site configuration: An unknown error occurred."
+        );
+      }
+    },
+    /**
+     * Initializes the StudioCMS Ghost User.
+     *
+     * The ghost user is a default user that is used to perform actions on behalf of the system as well as to replace deleted users.
+     *
+     * @returns A promise that resolves to the ghost user record.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while creating the ghost user.
+     */
+    ghostUser: async () => {
+      try {
+        const ghostUser = await AUTH.user.ghost.verifyExists();
+        if (!ghostUser) {
+          return await AUTH.user.ghost.create();
+        }
+        const ghostUserRecord = await AUTH.user.ghost.get();
+        if (!ghostUserRecord) {
+          throw new StudioCMS_SDK_Error(
+            "Error getting ghost user from database: The ghost user may not exist yet."
+          );
+        }
+        return ghostUserRecord;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(`Error creating ghost user: ${error.message}`, error.stack);
+        }
+        throw new StudioCMS_SDK_Error("Error creating ghost user: An unknown error occurred.");
+      }
+    }
+  };
+  const GET = {
+    /**
+     * Retrieves data from the database
+     */
+    database: {
+      /**
+       * Retrieves all users from the database.
+       *
+       * @returns A promise that resolves to an array of combined user data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the users.
+       */
+      users: async () => {
+        try {
+          const combinedUserData = [];
+          const users = await db.select().from(tsUsers);
+          for (const user of users) {
+            const UserData = await collectUserData(user);
+            combinedUserData.push(UserData);
+          }
+          return combinedUserData;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting users: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting users: An unknown error occurred.");
+        }
+      },
+      /**
+       * Retrieves all pages from the database.
+       *
+       * @returns A promise that resolves to an array of combined page data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the pages.
+       */
+      pages: async (includeDrafts = false, tree) => {
+        try {
+          const pages = [];
+          let pagesRaw = await db.select().from(tsPageData);
+          if (!includeDrafts) {
+            pagesRaw = pagesRaw.filter(({ draft }) => draft === false || draft === null);
+          }
+          const folders = tree || await buildFolderTree();
+          for (const page of pagesRaw) {
+            const PageData = await collectPageData(page, folders);
+            pages.push(PageData);
+          }
+          return pages;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting pages: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting pages: An unknown error occurred.");
+        }
+      },
+      /**
+       * Retrieves the site configuration from the database.
+       *
+       * @returns A promise that resolves to the site configuration.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the site configuration.
+       */
+      config: async () => {
+        try {
+          return await db.select().from(tsSiteConfig).where(eq(tsSiteConfig.id, CMSSiteConfigId)).get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error getting site configuration: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error(
+            "Error getting site configuration: An unknown error occurred."
+          );
+        }
+      },
+      folders: async () => {
+        try {
+          return await db.select().from(tsPageFolderStructure);
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting folders: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting folders: An unknown error occurred.");
+        }
+      }
+    },
+    /**
+     * Retrieves data from the database by ID.
+     */
+    databaseEntry: {
+      /**
+       * Retrieves a user from the database
+       */
+      users: {
+        /**
+         * Retrieves a user by ID.
+         *
+         * @param id - The ID of the user to retrieve.
+         * @returns A promise that resolves to the user data.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while getting the user.
+         */
+        byId: async (id) => {
+          try {
+            const user = await db.select().from(tsUsers).where(eq(tsUsers.id, id)).get();
+            if (!user) return void 0;
+            return await collectUserData(user);
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error getting user by ID: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error("Error getting user by ID: An unknown error occurred.");
+          }
+        },
+        /**
+         * Retrieves a user by username.
+         *
+         * @param username - The username of the user to retrieve.
+         * @returns A promise that resolves to the user data.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while getting the user.
+         */
+        byUsername: async (username) => {
+          try {
+            const user = await db.select().from(tsUsers).where(eq(tsUsers.username, username)).get();
+            if (!user) return void 0;
+            return await collectUserData(user);
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error getting user by username: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error(
+              "Error getting user by username: An unknown error occurred."
+            );
+          }
+        },
+        /**
+         * Retrieves a user by email.
+         *
+         * @param email - The email of the user to retrieve.
+         * @returns A promise that resolves to the user data.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while getting the user.
+         */
+        byEmail: async (email) => {
+          try {
+            const user = await db.select().from(tsUsers).where(eq(tsUsers.email, email)).get();
+            if (!user) return void 0;
+            return await collectUserData(user);
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error getting user by email: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error(
+              "Error getting user by email: An unknown error occurred."
+            );
+          }
+        }
+      },
+      /**
+       * Retrieves a page from the database
+       */
+      pages: {
+        /**
+         * Retrieves a page by ID.
+         *
+         * @param id - The ID of the page to retrieve.
+         * @returns A promise that resolves to the page data.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while getting the page.
+         */
+        byId: async (id, tree) => {
+          try {
+            const page = await db.select().from(tsPageData).where(eq(tsPageData.id, id)).get();
+            if (!page) return void 0;
+            const folders = tree || await buildFolderTree();
+            return await collectPageData(page, folders);
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error getting page by ID: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error("Error getting page by ID: An unknown error occurred.");
+          }
+        },
+        /**
+         * Retrieves a page by slug.
+         *
+         * @param slug - The slug of the page to retrieve.
+         * @returns A promise that resolves to the page data.
+         * @throws {StudioCMS_SDK_Error} If an error occurs while getting the page.
+         */
+        bySlug: async (slug, tree) => {
+          try {
+            const page = await db.select().from(tsPageData).where(eq(tsPageData.slug, slug)).get();
+            if (!page) return void 0;
+            const folders = tree || await buildFolderTree();
+            return await collectPageData(page, folders);
+          } catch (error) {
+            if (error instanceof Error) {
+              throw new StudioCMS_SDK_Error(
+                `Error getting page by slug: ${error.message}`,
+                error.stack
+              );
+            }
+            throw new StudioCMS_SDK_Error("Error getting page by slug: An unknown error occurred.");
+          }
+        }
+      },
+      folder: async (id) => {
+        try {
+          return await db.select().from(tsPageFolderStructure).where(eq(tsPageFolderStructure.id, id)).get();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting folders: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting folders: An unknown error occurred.");
+        }
+      }
+    },
+    /**
+     * Retrieves data from the database tables without any additional processing.
+     */
+    databaseTable: {
+      /**
+       * Retrieves all data from the users table.
+       *
+       * @returns A promise that resolves to an array of user data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the users.
+       */
+      users: async () => await db.select().from(tsUsers),
+      /**
+       * Retrieves all data from the OAuth accounts table.
+       *
+       * @returns A promise that resolves to an array of OAuth account data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the OAuth accounts.
+       */
+      oAuthAccounts: async () => await db.select().from(tsOAuthAccounts),
+      /**
+       * Retrieves all data from the session table.
+       *
+       * @returns A promise that resolves to an array of session data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the sessions.
+       */
+      sessionTable: async () => await db.select().from(tsSessionTable),
+      /**
+       * Retrieves all data from the permissions table.
+       *
+       * @returns A promise that resolves to an array of permission data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the permissions.
+       */
+      permissions: async () => await db.select().from(tsPermissions),
+      /**
+       * Retrieves all data from the page data table.
+       *
+       * @returns A promise that resolves to an array of page data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the pages.
+       */
+      pageData: async () => await db.select().from(tsPageData),
+      /**
+       * Retrieves all data from the page data tags table.
+       *
+       * @returns A promise that resolves to an array of page data tags.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the page data tags.
+       */
+      pageDataTags: async () => await db.select().from(tsPageDataTags),
+      /**
+       * Retrieves all data from the page data categories table.
+       *
+       * @returns A promise that resolves to an array of page data categories.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the page data categories.
+       */
+      pageDataCategories: async () => await db.select().from(tsPageDataCategories),
+      /**
+       * Retrieves all data from the page content table.
+       *
+       * @returns A promise that resolves to an array of page content.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the page content.
+       */
+      pageContent: async () => await db.select().from(tsPageContent),
+      /**
+       * Retrieves all data from the site config table.
+       *
+       * @returns A promise that resolves to an array of site configuration data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the site configuration.
+       */
+      siteConfig: async () => await db.select().from(tsSiteConfig).where(eq(tsSiteConfig.id, CMSSiteConfigId)).get(),
+      /**
+       * Retrieves all data from the diff tracking table.
+       *
+       * @returns A promise that resolves to an array of diff tracking data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the diff tracking data.
+       */
+      diffTracking: async () => await db.select().from(tsDiffTracking),
+      /**
+       * Retrieves all data from the page folder structure table.
+       *
+       * @returns A promise that resolves to an array of page folder structure data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the page folder structure data.
+       */
+      pageFolderStructure: async () => await db.select().from(tsPageFolderStructure)
+    },
+    /**
+     * Retrieve Permission Lists
+     */
+    permissionsLists: {
+      /**
+       * Retrieves all permissions for users in the database.
+       *
+       * @returns A promise that resolves to an array of combined rank data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the permissions.
+       */
+      all: async () => {
+        try {
+          const [currentPermittedUsers, existingUsers] = await db.batch([
+            db.select().from(tsPermissions),
+            db.select().from(tsUsers)
+          ]);
+          const owners = verifyRank(existingUsers, currentPermittedUsers, "owner");
+          const admins = verifyRank(existingUsers, currentPermittedUsers, "admin");
+          const editors = verifyRank(existingUsers, currentPermittedUsers, "editor");
+          const visitors = verifyRank(existingUsers, currentPermittedUsers, "visitor");
+          return [
+            ...combineRanks("owner", owners),
+            ...combineRanks("admin", admins),
+            ...combineRanks("editor", editors),
+            ...combineRanks("visitor", visitors)
+          ];
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting users: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting users: An unknown error occurred.");
+        }
+      },
+      /**
+       * Retrieves all owners in the database.
+       *
+       * @returns A promise that resolves to an array of combined rank data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the owners.
+       */
+      owners: async () => {
+        try {
+          const [currentPermittedUsers, existingUsers] = await db.batch([
+            db.select().from(tsPermissions),
+            db.select().from(tsUsers)
+          ]);
+          return verifyRank(existingUsers, currentPermittedUsers, "owner");
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting users: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting users: An unknown error occurred.");
+        }
+      },
+      /**
+       * Retrieves all admins in the database.
+       *
+       * @returns A promise that resolves to an array of combined rank data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the admins.
+       */
+      admins: async () => {
+        try {
+          const [currentPermittedUsers, existingUsers] = await db.batch([
+            db.select().from(tsPermissions),
+            db.select().from(tsUsers)
+          ]);
+          return verifyRank(existingUsers, currentPermittedUsers, "admin");
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting users: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting users: An unknown error occurred.");
+        }
+      },
+      /**
+       * Retrieves all editors in the database.
+       *
+       * @returns A promise that resolves to an array of combined rank data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the editors.
+       */
+      editors: async () => {
+        try {
+          const [currentPermittedUsers, existingUsers] = await db.batch([
+            db.select().from(tsPermissions),
+            db.select().from(tsUsers)
+          ]);
+          return verifyRank(existingUsers, currentPermittedUsers, "editor");
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting users: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting users: An unknown error occurred.");
+        }
+      },
+      /**
+       * Retrieves all visitors in the database.
+       *
+       * @returns A promise that resolves to an array of combined rank data.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while getting the visitors.
+       */
+      visitors: async () => {
+        try {
+          const [currentPermittedUsers, existingUsers] = await db.batch([
+            db.select().from(tsPermissions),
+            db.select().from(tsUsers)
+          ]);
+          return verifyRank(existingUsers, currentPermittedUsers, "visitor");
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error getting users: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error getting users: An unknown error occurred.");
+        }
+      }
+    },
+    /**
+     * Retrieves data from the database by package.
+     */
+    packagePages: async (packageName, tree) => {
+      try {
+        const pages = [];
+        const pagesRaw = await db.select().from(tsPageData).where(eq(tsPageData.package, packageName));
+        const folders = tree || await buildFolderTree();
+        for (const page of pagesRaw) {
+          const PageData = await collectPageData(page, folders);
+          pages.push(PageData);
+        }
+        return pages;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(`Error getting pages: ${error.message}`, error.stack);
+        }
+        throw new StudioCMS_SDK_Error("Error getting pages: An unknown error occurred.");
+      }
+    }
+  };
+  const POST = {
+    /**
+     * Inserts data into the database by Entry
+     */
+    databaseEntry: {
+      /**
+       * Insert a new page into the database.
+       *
+       * @param pageData - The data to insert into the page data table.
+       * @param pageContent - The data to insert into the page content table.
+       * @returns A promise that resolves to the inserted page data and page content.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the page.
+       */
+      pages: async (pageData, pageContent) => {
+        try {
+          const newContentID = pageData.id || crypto.randomUUID().toString();
+          const {
+            id = newContentID,
+            title,
+            slug,
+            description,
+            authorId = null,
+            package: packageName = "studiocms",
+            contentLang = "default",
+            heroImage = "",
+            showOnNav = false,
+            showAuthor = false,
+            showContributors = false,
+            categories = [],
+            tags = [],
+            contributorIds = [],
+            draft = false,
+            parentFolder = null
+          } = pageData;
+          const stringified = {
+            categories: categories || [],
+            tags: tags || [],
+            contributorIds: contributorIds || []
+          };
+          const contentData = {
+            id: crypto.randomUUID().toString(),
+            contentId: newContentID,
+            contentLang,
+            content: pageContent.content || ""
+          };
+          const NOW = /* @__PURE__ */ new Date();
+          const [newPageData, newPageContent] = await db.batch([
+            db.insert(tsPageData).values({
+              id,
+              title,
+              slug,
+              description,
+              authorId,
+              contentLang,
+              heroImage,
+              showAuthor,
+              showContributors,
+              showOnNav,
+              draft,
+              parentFolder,
+              package: packageName,
+              publishedAt: NOW,
+              updatedAt: NOW,
+              ...stringified
+            }).returning({ id: tsPageData.id }),
+            db.insert(tsPageContent).values(contentData).returning({ id: tsPageContent.id })
+          ]);
+          return {
+            pageData: newPageData,
+            pageContent: newPageContent
+          };
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error inserting page: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error inserting page: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts new page content into the database.
+       *
+       * @param pageContent - The data to insert into the page content table.
+       * @returns A promise that resolves to the inserted page content.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the page content.
+       */
+      pageContent: async (pageContent) => {
+        try {
+          return await db.insert(tsPageContent).values({
+            id: pageContent.id || crypto.randomUUID().toString(),
+            contentId: pageContent.contentId,
+            contentLang: pageContent.contentLang || "default",
+            content: pageContent.content || ""
+          }).returning({ id: tsPageContent.id });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error inserting page content: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error inserting page content: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts a new tag into the database.
+       *
+       * @param tag - The data to insert into the page data tags table.
+       * @returns A promise that resolves to the inserted tag.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the tag.
+       */
+      tags: async (tag) => {
+        try {
+          return await db.insert(tsPageDataTags).values({
+            name: tag.name,
+            description: tag.description,
+            slug: tag.slug,
+            meta: JSON.stringify(tag.meta),
+            id: tag.id || generateRandomIDNumber(9)
+          }).returning({ id: tsPageDataTags.id });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error inserting tag: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error inserting tag: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts a new category into the database.
+       *
+       * @param category - The data to insert into the page data categories table.
+       * @returns A promise that resolves to the inserted category.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the category.
+       */
+      categories: async (category) => {
+        try {
+          return await db.insert(tsPageDataCategories).values({
+            name: category.name,
+            description: category.description,
+            slug: category.slug,
+            meta: JSON.stringify(category.meta),
+            id: category.id || generateRandomIDNumber(9)
+          }).returning({ id: tsPageDataCategories.id });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error inserting category: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error inserting category: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts a new permission into the database.
+       *
+       * @param userId - The ID of the user to assign the rank to.
+       * @param rank - The rank to assign to the user.
+       * @returns A promise that resolves to the inserted permission.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the permission.
+       */
+      permissions: async (userId, rank) => {
+        try {
+          const userAlreadyExists = await db.select().from(tsPermissions).where(eq(tsPermissions.user, userId)).get();
+          if (userAlreadyExists) {
+            throw new StudioCMS_SDK_Error(
+              "User already is already assigned a rank, please update the existing rank instead."
+            );
+          }
+          return await db.insert(tsPermissions).values({
+            user: userId,
+            rank
+          }).returning({ user: tsPermissions.user, rank: tsPermissions.rank });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error inserting permissions: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error inserting permissions: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts a new diff tracking entry into the database.
+       *
+       * @param diff - The data to insert into the diff tracking table.
+       * @returns A promise that resolves to the inserted diff tracking entry.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the diff tracking entry.
+       */
+      diffTracking: async (diff) => {
+        try {
+          return await db.insert(tsDiffTracking).values({
+            id: diff.id || crypto.randomUUID().toString(),
+            userId: diff.userId,
+            pageId: diff.pageId,
+            diff: diff.diff || "",
+            timestamp: diff.timestamp || /* @__PURE__ */ new Date(),
+            pageContentStart: diff.pageContentStart,
+            pageMetaData: JSON.stringify(diff.pageMetaData || {})
+          }).returning();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error inserting diff tracking: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error(
+            "Error inserting diff tracking: An unknown error occurred."
+          );
+        }
+      },
+      /**
+       * Inserts a new folder into the database.
+       *
+       * @param folder - The data to insert into the page folder structure table.
+       * @returns A promise that resolves to the inserted folder.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the folder.
+       */
+      folder: async (folder) => {
+        try {
+          return await db.insert(tsPageFolderStructure).values({
+            id: folder.id || crypto.randomUUID().toString(),
+            name: folder.name,
+            parent: folder.parent || null
+          }).returning();
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error inserting folder: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error inserting folder: An unknown error occurred.");
+        }
+      }
+    },
+    /**
+     * Inserts data into the database by Array of Entries
+     */
+    databaseEntries: {
+      /**
+       * Inserts multiple tags into the database.
+       *
+       * @param data - The data to insert into the page data tags table.
+       * @returns A promise that resolves to the inserted tags.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the tags.
+       */
+      tags: async (data) => {
+        try {
+          return await db.insert(tsPageDataTags).values(
+            data.map((tag) => {
+              return {
+                id: tag.id || generateRandomIDNumber(9),
+                name: tag.name,
+                slug: tag.slug,
+                description: tag.description,
+                meta: JSON.stringify(tag.meta)
+              };
+            })
+          ).returning({ id: tsPageDataTags.id });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error inserting tags: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error inserting tags: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts multiple categories into the database.
+       *
+       * @param data - The data to insert into the page data categories table.
+       * @returns A promise that resolves to the inserted categories.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the categories.
+       */
+      categories: async (data) => {
+        try {
+          return await db.insert(tsPageDataCategories).values(
+            data.map((category) => {
+              return {
+                id: category.id || generateRandomIDNumber(9),
+                name: category.name,
+                slug: category.slug,
+                description: category.description,
+                meta: JSON.stringify(category.meta)
+              };
+            })
+          ).returning({ id: tsPageDataCategories.id });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error inserting categories: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error inserting categories: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts multiple permissions into the database.
+       *
+       * @param data - The data to insert into the permissions table.
+       * @returns A promise that resolves to the inserted permissions.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the permissions.
+       */
+      permissions: async (data) => {
+        try {
+          const currentPermittedUsers = await db.select().from(tsPermissions);
+          for (const permission of data) {
+            const userAlreadyExists = currentPermittedUsers.find(
+              (user) => user.user === permission.user
+            );
+            if (userAlreadyExists) {
+              throw new Error(
+                `User with ID ${permission.user} already has a rank assigned. Please update the existing rank instead.`
+              );
+            }
+          }
+          return await db.insert(tsPermissions).values(
+            data.map((permission) => {
+              return {
+                user: permission.user,
+                rank: permission.rank
+              };
+            })
+          ).returning({ user: tsPermissions.user, rank: tsPermissions.rank });
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(
+              `Error inserting permissions: ${error.message}`,
+              error.stack
+            );
+          }
+          throw new StudioCMS_SDK_Error("Error inserting permissions: An unknown error occurred.");
+        }
+      },
+      /**
+       * Inserts multiple pages into the database.
+       *
+       * @param pages - The data to insert into the page data and page content tables.
+       * @returns A promise that resolves to the inserted pages.
+       * @throws {StudioCMS_SDK_Error} If an error occurs while inserting the pages.
+       */
+      pages: async (pages) => {
+        try {
+          const queries = [];
+          for (const { pageData, pageContent } of pages) {
+            const newContentID = pageData.id || crypto.randomUUID().toString();
+            const {
+              title,
+              slug,
+              description,
+              authorId = null,
+              package: packageName = "studiocms",
+              contentLang = "default",
+              heroImage = "",
+              showOnNav = false,
+              showAuthor = false,
+              showContributors = false,
+              categories = [],
+              tags = [],
+              contributorIds = [],
+              draft = false,
+              parentFolder = null,
+              id = newContentID
+            } = pageData;
+            const stringified = {
+              categories: categories || [],
+              tags: tags || [],
+              contributorIds: contributorIds || []
+            };
+            const contentData = {
+              id: crypto.randomUUID().toString(),
+              contentId: newContentID,
+              contentLang: pageContent.contentLang || "default",
+              content: pageContent.content || ""
+            };
+            const NOW = /* @__PURE__ */ new Date();
+            queries.push(
+              db.insert(tsPageData).values({
+                id,
+                title,
+                slug,
+                description,
+                authorId,
+                contentLang,
+                heroImage,
+                showAuthor,
+                showContributors,
+                showOnNav,
+                draft,
+                parentFolder,
+                package: packageName,
+                publishedAt: NOW,
+                updatedAt: NOW,
+                ...stringified
+              }).returning(),
+              db.insert(tsPageContent).values(contentData).returning()
+            );
+          }
+          const [head, ...tail] = queries;
+          if (head) {
+            await db.batch([head, ...tail]);
+          }
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new StudioCMS_SDK_Error(`Error inserting pages: ${error.message}`, error.stack);
+          }
+          throw new StudioCMS_SDK_Error("Error inserting pages: An unknown error occurred.");
+        }
+      }
+    }
+  };
+  const UPDATE = {
+    /**
+     * Updates a page in the database.
+     *
+     * @param data - The data to update in the page data table.
+     * @returns A promise that resolves to the updated page data.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while updating the page.
+     */
+    page: async (data) => {
+      try {
+        return await db.update(tsPageData).set(data).where(eq(tsPageData.id, data.id)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(`Error updating page: ${error.message}`, error.stack);
+        }
+        throw new StudioCMS_SDK_Error("Error updating page: An unknown error occurred.");
+      }
+    },
+    /**
+     * Updates a page content in the database.
+     *
+     * @param data - The data to update in the page content table.
+     * @returns A promise that resolves to the updated page content.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while updating the page content.
+     */
+    pageContent: async (data) => {
+      try {
+        return await db.update(tsPageContent).set(data).where(eq(tsPageContent.id, data.id)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error updating page content: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error("Error updating page content: An unknown error occurred.");
+      }
+    },
+    /**
+     * Updates a tag in the database.
+     *
+     * @param data - The data to update in the page data tags table.
+     * @returns A promise that resolves to the updated tag.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while updating the tag.
+     */
+    tags: async (data) => {
+      try {
+        return await db.update(tsPageDataTags).set(data).where(eq(tsPageDataTags.id, data.id)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(`Error updating tags: ${error.message}`, error.stack);
+        }
+        throw new StudioCMS_SDK_Error("Error updating tags: An unknown error occurred.");
+      }
+    },
+    /**
+     * Updates a category in the database.
+     *
+     * @param data - The data to update in the page data categories table.
+     * @returns A promise that resolves to the updated category.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while updating the category.
+     */
+    categories: async (data) => {
+      try {
+        return await db.update(tsPageDataCategories).set(data).where(eq(tsPageDataCategories.id, data.id)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(`Error updating categories: ${error.message}`, error.stack);
+        }
+        throw new StudioCMS_SDK_Error("Error updating categories: An unknown error occurred.");
+      }
+    },
+    /**
+     * Updates a permission in the database.
+     *
+     * @param data - The data to update in the permissions table.
+     * @returns A promise that resolves to the updated permission.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while updating the permission.
+     */
+    permissions: async (data) => {
+      try {
+        return await db.update(tsPermissions).set(data).where(eq(tsPermissions.user, data.user)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error updating permissions: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error("Error updating permissions: An unknown error occurred.");
+      }
+    },
+    /**
+     * Updates a site configuration in the database.
+     *
+     * @param data - The data to update in the site config table.
+     * @returns A promise that resolves to the updated site configuration.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while updating the site configuration.
+     */
+    siteConfig: async (data) => {
+      try {
+        return await db.update(tsSiteConfig).set(data).where(eq(tsSiteConfig.id, data.id)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error updating site config: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error("Error updating site config: An unknown error occurred.");
+      }
+    },
+    folder: async (data) => {
+      try {
+        return await db.update(tsPageFolderStructure).set(data).where(eq(tsPageFolderStructure.id, data.id)).returning().get();
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(`Error updating folder: ${error.message}`, error.stack);
+        }
+        throw new StudioCMS_SDK_Error("Error updating folder: An unknown error occurred.");
+      }
+    }
+  };
+  const DELETE = {
+    /**
+     * Deletes a page from the database.
+     *
+     * @param id - The ID of the page to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the page.
+     */
+    page: async (id) => {
+      try {
+        return await db.batch([
+          db.delete(tsDiffTracking).where(eq(tsDiffTracking.pageId, id)),
+          db.delete(tsPageContent).where(eq(tsPageContent.contentId, id)),
+          db.delete(tsPageData).where(eq(tsPageData.id, id))
+        ]).then(() => {
+          return {
+            status: "success",
+            message: `Page with ID ${id} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting page with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting page with ID ${id}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a page content from the database.
+     *
+     * @param id - The ID of the page content to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the page content.
+     */
+    pageContent: async (id) => {
+      try {
+        return await db.delete(tsPageContent).where(eq(tsPageContent.contentId, id)).then(() => {
+          return {
+            status: "success",
+            message: `Page content with ID ${id} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting page content with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting page content with ID ${id}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a page content lang from the database.
+     *
+     * @param id - The ID of the page content to delete.
+     * @param lang - The lang of the page content to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the page content lang.
+     */
+    pageContentLang: async (id, lang) => {
+      try {
+        return await db.delete(tsPageContent).where(and(eq(tsPageContent.contentId, id), eq(tsPageContent.contentLang, lang))).then(() => {
+          return {
+            status: "success",
+            message: `Page content with ID ${id} and lang ${lang} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting page content with ID ${id} and lang ${lang}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting page content with ID ${id} and lang ${lang}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a tag from the database.
+     *
+     * @param id - The ID of the tag to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the tag.
+     */
+    tags: async (id) => {
+      try {
+        return await db.delete(tsPageDataTags).where(eq(tsPageDataTags.id, id)).then(() => {
+          return {
+            status: "success",
+            message: `Tag with ID ${id} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting tag with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting tag with ID ${id}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a category from the database.
+     *
+     * @param id - The ID of the category to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the category.
+     */
+    categories: async (id) => {
+      try {
+        return await db.delete(tsPageDataCategories).where(eq(tsPageDataCategories.id, id)).then(() => {
+          return {
+            status: "success",
+            message: `Category with ID ${id} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting category with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting category with ID ${id}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a permission from the database.
+     *
+     * @param userId - The ID of the user to delete the permission for.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the permission.
+     */
+    permissions: async (userId) => {
+      try {
+        return await db.delete(tsPermissions).where(eq(tsPermissions.user, userId)).then(() => {
+          return {
+            status: "success",
+            message: `Permissions for user with ID ${userId} have been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting permissions for user with ID ${userId}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting permissions for user with ID ${userId}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a site configuration from the database.
+     *
+     * @param id - The ID of the site configuration to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the site configuration.
+     */
+    diffTracking: async (id) => {
+      try {
+        return await db.delete(tsDiffTracking).where(eq(tsDiffTracking.id, id)).then(() => {
+          return {
+            status: "success",
+            message: `Diff tracking with ID ${id} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting diff tracking with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting diff tracking with ID ${id}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a folder from the database.
+     *
+     * @param id - The ID of the folder to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the folder.
+     */
+    folder: async (id) => {
+      try {
+        return await db.delete(tsPageFolderStructure).where(eq(tsPageFolderStructure.id, id)).then(() => {
+          return {
+            status: "success",
+            message: `Folder with ID ${id} has been deleted successfully`
+          };
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting folder with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting folder with ID ${id}: An unknown error occurred.`
+        );
+      }
+    },
+    /**
+     * Deletes a user from the database.
+     *
+     * @param id - The ID of the user to delete.
+     * @returns A promise that resolves to a deletion response.
+     * @throws {StudioCMS_SDK_Error} If an error occurs while deleting the user.
+     */
+    user: async (id) => {
+      try {
+        const verifyNoReference = await clearUserReferences(id);
+        if (verifyNoReference) {
+          return await db.delete(tsUsers).where(eq(tsUsers.id, id)).then(() => {
+            return {
+              status: "success",
+              message: `User with ID ${id} has been deleted successfully`
+            };
+          });
+        }
+        throw new StudioCMS_SDK_Error(
+          `There was an issue deleting User with ID ${id}. Please manually remove all references before deleting the user. Or try again.`
+        );
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new StudioCMS_SDK_Error(
+            `Error deleting user with ID ${id}: ${error.message}`,
+            error.stack
+          );
+        }
+        throw new StudioCMS_SDK_Error(
+          `Error deleting user with ID ${id}: An unknown error occurred.`
+        );
+      }
+    }
+  };
+  return {
+    addPageToFolderTree,
+    findNodeById,
+    findNodeByPath,
+    findNodesAlongPath,
+    getFullPath,
+    parseIdNumberArray,
+    parseIdStringArray,
+    generateRandomIDNumber,
+    generateToken,
+    testToken,
+    combineRanks,
+    verifyRank,
+    buildFolderTree,
+    getAvailableFolders,
+    clearUserReferences,
+    collectCategories,
+    collectTags,
+    collectPageData,
+    collectUserData,
+    generateRandomPassword,
+    resetTokenBucket,
+    diffTracking,
+    AUTH,
+    INIT,
+    GET,
+    POST,
+    UPDATE,
+    DELETE,
+    db,
+    REST_API
+  };
+}
+export {
+  studiocmsSDKCore
+};