studiocms 0.1.0-beta.10

package/dist/sdk/errors.d.ts

@@ -0,0 +1,21 @@
+import { StudioCMSError } from '../errors.js';
+/**
+ * Represents an error specific to the StudioCMS SDK.
+ * This class extends the `StudioCMSError` class to provide additional context
+ * and functionality for errors occurring within the StudioCMS SDK.
+ *
+ * @extends {AstroError}
+ */
+export declare class StudioCMS_SDK_Error extends StudioCMSError {
+    name: string;
+}
+/**
+ * Represents an error specific to the StudioCMS cache operations.
+ * This class extends the `StudioCMS_SDK_Error` to provide more context
+ * about errors that occur within the caching mechanism of the StudioCMS.
+ *
+ * @extends StudioCMS_SDK_Error
+ */
+export declare class StudioCMSCacheError extends StudioCMS_SDK_Error {
+    name: string;
+}

package/dist/sdk/errors.js

@@ -0,0 +1,11 @@
+import { StudioCMSError } from "../errors.js";
+class StudioCMS_SDK_Error extends StudioCMSError {
+  name = "StudioCMS SDK Error";
+}
+class StudioCMSCacheError extends StudioCMS_SDK_Error {
+  name = "StudioCMS Cache Error";
+}
+export {
+  StudioCMSCacheError,
+  StudioCMS_SDK_Error
+};

package/dist/sdk/index.d.ts

@@ -0,0 +1,371 @@
+/**
+ * The main SDK export for StudioCMS.
+ *
+ * This constant provides access to the core functionality of the StudioCMS SDK.
+ */
+export declare const studioCMS_SDK: {
+    addPageToFolderTree: typeof import("./lib/foldertree.js").addPageToFolderTree;
+    findNodeById: typeof import("./lib/foldertree.js").findNodeById;
+    findNodeByPath: typeof import("./lib/foldertree.js").findNodeByPath;
+    findNodesAlongPath: typeof import("./lib/foldertree.js").findNodesAlongPath;
+    getFullPath: typeof import("./lib/foldertree.js").getFullPath;
+    parseIdNumberArray: typeof import("./lib/parsers.js").parseIdNumberArray;
+    parseIdStringArray: typeof import("./lib/parsers.js").parseIdStringArray;
+    generateRandomIDNumber: typeof import("./lib/generators.js").generateRandomIDNumber;
+    generateToken: typeof import("./lib/generators.js").generateToken;
+    testToken: typeof import("./lib/generators.js").testToken;
+    combineRanks: typeof import("./lib/users.js").combineRanks;
+    verifyRank: typeof import("./lib/users.js").verifyRank;
+    buildFolderTree: () => Promise<import("./types/index.js").FolderNode[]>;
+    getAvailableFolders: () => Promise<import("./types/index.js").FolderListItem[]>;
+    clearUserReferences: (userId: string) => Promise<boolean>;
+    collectCategories: (categoryIds: number[]) => Promise<import("./types/index.js").CombinedPageData["categories"]>;
+    collectTags: (tagIds: number[]) => Promise<import("./types/index.js").CombinedPageData["tags"]>;
+    collectPageData: (page: import("./types/tsAlias.js").tsPageDataSelect, tree: import("./types/index.js").FolderNode[]) => Promise<import("./types/index.js").CombinedPageData>;
+    collectUserData: (user: import("./types/tsAlias.js").tsUsersSelect) => Promise<import("./types/index.js").CombinedUserData>;
+    generateRandomPassword: typeof import("./lib/generators.js").generateRandomPassword;
+    resetTokenBucket: {
+        new: (userId: string) => Promise<{
+            userId: string;
+            id: string;
+            token: string;
+        }>;
+        delete: (userId: string) => Promise<void>;
+        check: (token: string) => Promise<boolean>;
+    };
+    diffTracking: {
+        insert: (userId: string, pageId: string, data: {
+            content: {
+                start: string;
+                end: string;
+            };
+            metaData: {
+                start: Partial<import("./types/tsAlias.js").tsPageDataSelect>;
+                end: Partial<import("./types/tsAlias.js").tsPageDataSelect>;
+            };
+        }, diffLength: number) => Promise<{
+            userId: string;
+            id: string;
+            pageId: string;
+            timestamp: Date | null;
+            pageMetaData: unknown;
+            pageContentStart: string;
+            diff: string | null;
+        }>;
+        clear: (pageId: string) => Promise<void>;
+        get: {
+            byPageId: {
+                all: (pageId: string) => Promise<{
+                    userId: string;
+                    id: string;
+                    pageId: string;
+                    timestamp: Date | null;
+                    pageMetaData: unknown;
+                    pageContentStart: string;
+                    diff: string | null;
+                }[]>;
+                latest: (pageId: string, count: number) => Promise<{
+                    userId: string;
+                    id: string;
+                    pageId: string;
+                    timestamp: Date | null;
+                    pageMetaData: unknown;
+                    pageContentStart: string;
+                    diff: string | null;
+                }[]>;
+            };
+            byUserId: {
+                all: (userId: string) => Promise<{
+                    userId: string;
+                    id: string;
+                    pageId: string;
+                    timestamp: Date | null;
+                    pageMetaData: unknown;
+                    pageContentStart: string;
+                    diff: string | null;
+                }[]>;
+                latest: (userId: string, count: number) => Promise<{
+                    userId: string;
+                    id: string;
+                    pageId: string;
+                    timestamp: Date | null;
+                    pageMetaData: unknown;
+                    pageContentStart: string;
+                    diff: string | null;
+                }[]>;
+            };
+            single: (id: string) => Promise<{
+                userId: string;
+                id: string;
+                pageId: string;
+                timestamp: Date | null;
+                pageMetaData: unknown;
+                pageContentStart: string;
+                diff: string | null;
+            } | undefined>;
+            withHtml: (id: string, options?: import("diff2html").Diff2HtmlConfig) => Promise<{
+                metadataDiffHtml: string;
+                contentDiffHtml: string;
+                userId: string;
+                id: string;
+                pageId: string;
+                timestamp: Date | null;
+                pageMetaData: unknown;
+                pageContentStart: string;
+                diff: string | null;
+            }>;
+        };
+        revertToDiff: (id: string, type: "content" | "data" | "both") => Promise<{
+            userId: string;
+            id: string;
+            pageId: string;
+            timestamp: Date | null;
+            pageMetaData: unknown;
+            pageContentStart: string;
+            diff: string | null;
+        }>;
+    };
+    AUTH: {
+        oAuth: {
+            create: (data: import("./types/tsAlias.js").tsOAuthAccountsSelect) => Promise<import("./types/tsAlias.js").tsOAuthAccountsSelect>;
+            delete: (userId: string, provider: string) => Promise<import("./types/index.js").DeletionResponse>;
+            searchProvidersForId: (providerId: string, userId: string) => Promise<import("./types/tsAlias.js").tsOAuthAccountsSelect | undefined>;
+        };
+        permission: {
+            currentStatus: (userId: string) => Promise<import("./types/tsAlias.js").tsPermissionsSelect | undefined>;
+        };
+        session: {
+            create: (data: import("./types/tsAlias.js").tsSessionTableInsert) => Promise<import("./types/tsAlias.js").tsSessionTableSelect>;
+            sessionWithUser: (sessionId: string) => Promise<{
+                user: import("./types/tsAlias.js").tsUsersSelect;
+                session: import("./types/tsAlias.js").tsSessionTableSelect;
+            }[]>;
+            delete: (sessionId: string) => Promise<import("./types/index.js").DeletionResponse>;
+            update: (sessionId: string, newDate: Date) => Promise<import("./types/tsAlias.js").tsSessionTableSelect[]>;
+        };
+        user: {
+            create: (newUserData: import("./types/tsAlias.js").tsUsersInsert, rank?: "visitor" | "editor" | "admin" | "owner") => Promise<import("./types/tsAlias.js").tsUsersSelect>;
+            update: (userId: string, userData: import("./types/tsAlias.js").tsUsersUpdate) => Promise<import("./types/tsAlias.js").tsUsersSelect>;
+            searchUsersForUsernameOrEmail: (username: string, email: string) => Promise<{
+                usernameSearch: import("./types/tsAlias.js").tsUsersSelect[];
+                emailSearch: import("./types/tsAlias.js").tsUsersSelect[];
+            }>;
+            ghost: {
+                verifyExists: () => Promise<boolean>;
+                create: () => Promise<{
+                    name: string;
+                    username: string;
+                    email: string | null;
+                    id: string;
+                    url: string | null;
+                    avatar: string | null;
+                    password: string | null;
+                    updatedAt: Date | null;
+                    createdAt: Date | null;
+                }>;
+                get: () => Promise<{
+                    name: string;
+                    username: string;
+                    email: string | null;
+                    id: string;
+                    url: string | null;
+                    avatar: string | null;
+                    password: string | null;
+                    updatedAt: Date | null;
+                    createdAt: Date | null;
+                } | undefined>;
+            };
+        };
+    };
+    INIT: {
+        siteConfig: (config: import("./types/tsAlias.js").tsSiteConfigInsert) => Promise<import("./types/tsAlias.js").tsSiteConfigSelect>;
+        ghostUser: () => Promise<import("./types/tsAlias.js").tsUsersSelect>;
+    };
+    GET: {
+        database: {
+            users: () => Promise<import("./types/index.js").CombinedUserData[]>;
+            pages: (includeDrafts?: boolean, tree?: import("./types/index.js").FolderNode[]) => Promise<import("./types/index.js").CombinedPageData[]>;
+            config: () => Promise<import("./types/tsAlias.js").tsSiteConfigSelect | undefined>;
+            folders: () => Promise<import("./types/tsAlias.js").tsPageFolderSelect[]>;
+        };
+        databaseEntry: {
+            users: {
+                byId: (id: string) => Promise<import("./types/index.js").CombinedUserData | undefined>;
+                byUsername: (username: string) => Promise<import("./types/index.js").CombinedUserData | undefined>;
+                byEmail: (email: string) => Promise<import("./types/index.js").CombinedUserData | undefined>;
+            };
+            pages: {
+                byId: (id: string, tree?: import("./types/index.js").FolderNode[]) => Promise<import("./types/index.js").CombinedPageData | undefined>;
+                bySlug: (slug: string, tree?: import("./types/index.js").FolderNode[]) => Promise<import("./types/index.js").CombinedPageData | undefined>;
+            };
+            folder: (id: string) => Promise<import("./types/tsAlias.js").tsPageFolderSelect | undefined>;
+        };
+        databaseTable: {
+            users: () => Promise<{
+                name: string;
+                username: string;
+                email: string | null;
+                id: string;
+                url: string | null;
+                avatar: string | null;
+                password: string | null;
+                updatedAt: Date | null;
+                createdAt: Date | null;
+            }[]>;
+            oAuthAccounts: () => Promise<{
+                provider: string;
+                providerUserId: string;
+                userId: string;
+            }[]>;
+            sessionTable: () => Promise<{
+                userId: string;
+                id: string;
+                expiresAt: Date;
+            }[]>;
+            permissions: () => Promise<{
+                user: string;
+                rank: string;
+            }[]>;
+            pageData: () => Promise<{
+                title: string;
+                description: string;
+                id: string;
+                updatedAt: Date | null;
+                package: string;
+                showOnNav: boolean;
+                publishedAt: Date;
+                slug: string;
+                contentLang: string;
+                heroImage: string;
+                categories: unknown;
+                tags: unknown;
+                authorId: string | null;
+                contributorIds: unknown;
+                showAuthor: boolean | null;
+                showContributors: boolean | null;
+                parentFolder: string | null;
+                draft: boolean | null;
+            }[]>;
+            pageDataTags: () => Promise<{
+                meta: unknown;
+                name: string;
+                description: string;
+                id: number;
+                slug: string;
+            }[]>;
+            pageDataCategories: () => Promise<{
+                meta: unknown;
+                name: string;
+                description: string;
+                id: number;
+                slug: string;
+                parent: number | null;
+            }[]>;
+            pageContent: () => Promise<{
+                id: string;
+                contentLang: string;
+                content: string | null;
+                contentId: string;
+            }[]>;
+            siteConfig: () => Promise<{
+                title: string;
+                description: string;
+                id: number;
+                defaultOgImage: string | null;
+                siteIcon: string | null;
+                loginPageBackground: string;
+                loginPageCustomImage: string | null;
+                enableDiffs: boolean;
+                diffPerPage: number;
+                gridItems: unknown;
+            } | undefined>;
+            diffTracking: () => Promise<{
+                userId: string;
+                id: string;
+                pageId: string;
+                timestamp: Date | null;
+                pageMetaData: unknown;
+                pageContentStart: string;
+                diff: string | null;
+            }[]>;
+            pageFolderStructure: () => Promise<{
+                name: string;
+                id: string;
+                parent: string | null;
+            }[]>;
+        };
+        permissionsLists: {
+            all: () => Promise<import("./types/tableDefs.js").CombinedRank[]>;
+            owners: () => Promise<import("./types/tableDefs.js").SingleRank[]>;
+            admins: () => Promise<import("./types/tableDefs.js").SingleRank[]>;
+            editors: () => Promise<import("./types/tableDefs.js").SingleRank[]>;
+            visitors: () => Promise<import("./types/tableDefs.js").SingleRank[]>;
+        };
+        packagePages: (packageName: string, tree?: import("./types/index.js").FolderNode[]) => Promise<import("./types/index.js").CombinedPageData[]>;
+    };
+    POST: {
+        databaseEntry: {
+            pages: (pageData: import("./types/tsAlias.js").tsPageDataInsert, pageContent: import("./types/tsAlias.js").CombinedInsertContent) => Promise<import("./types/index.js").addDatabaseEntryInsertPage>;
+            pageContent: (pageContent: import("./types/tsAlias.js").tsPageContentInsert) => Promise<import("./types/tableDefs.js").PageContentReturnId[]>;
+            tags: (tag: import("./types/tsAlias.js").tsPageDataTagsInsert) => Promise<import("./types/tableDefs.js").PageDataTagsInsertResponse[]>;
+            categories: (category: import("./types/tsAlias.js").tsPageDataCategoriesInsert) => Promise<{
+                id: number;
+            }[]>;
+            permissions: (userId: string, rank: string) => Promise<import("./types/tsAlias.js").tsPermissionsSelect[]>;
+            diffTracking: (diff: import("./types/tsAlias.js").tsDiffTrackingInsert) => Promise<import("./types/tsAlias.js").tsDiffTrackingSelect[]>;
+            folder: (folder: import("./types/tsAlias.js").tsPageFolderInsert) => Promise<import("./types/tsAlias.js").tsPageFolderSelect[]>;
+        };
+        databaseEntries: {
+            tags: (data: import("./types/tsAlias.js").tsPageDataTagsInsert[]) => Promise<import("./types/tableDefs.js").PageDataTagsInsertResponse[]>;
+            categories: (data: import("./types/tsAlias.js").tsPageDataCategoriesInsert[]) => Promise<import("./types/tableDefs.js").PageDataCategoriesInsertResponse[]>;
+            permissions: (data: import("./types/tsAlias.js").tsPermissionsInsert[]) => Promise<import("./types/tsAlias.js").tsPermissionsSelect[]>;
+            pages: (pages: import("./types/index.js").MultiPageInsert) => Promise<void>;
+        };
+    };
+    UPDATE: {
+        page: (data: import("./types/tsAlias.js").tsPageDataSelect) => Promise<import("./types/tsAlias.js").tsPageDataSelect>;
+        pageContent: (data: import("./types/tsAlias.js").tsPageContentSelect) => Promise<import("./types/tsAlias.js").tsPageContentSelect>;
+        tags: (data: import("./types/tsAlias.js").tsPageDataTagsSelect) => Promise<import("./types/tsAlias.js").tsPageDataTagsSelect>;
+        categories: (data: import("./types/tsAlias.js").tsPageDataCategoriesSelect) => Promise<import("./types/tsAlias.js").tsPageDataCategoriesSelect>;
+        permissions: (data: import("./types/tsAlias.js").tsPermissionsSelect) => Promise<import("./types/tsAlias.js").tsPermissionsSelect>;
+        siteConfig: (data: import("./types/tsAlias.js").tsSiteConfigSelect) => Promise<import("./types/tsAlias.js").tsSiteConfigSelect>;
+        folder: (data: import("./types/tsAlias.js").tsPageFolderSelect) => Promise<import("./types/tsAlias.js").tsPageFolderSelect>;
+    };
+    DELETE: {
+        page: (id: string) => Promise<import("./types/index.js").DeletionResponse>;
+        pageContent: (id: string) => Promise<import("./types/index.js").DeletionResponse>;
+        pageContentLang: (id: string, lang: string) => Promise<import("./types/index.js").DeletionResponse>;
+        tags: (id: number) => Promise<import("./types/index.js").DeletionResponse>;
+        categories: (id: number) => Promise<import("./types/index.js").DeletionResponse>;
+        permissions: (userId: string) => Promise<import("./types/index.js").DeletionResponse>;
+        diffTracking: (id: string) => Promise<import("./types/index.js").DeletionResponse>;
+        folder: (id: string) => Promise<import("./types/index.js").DeletionResponse>;
+        user: (id: string) => Promise<import("./types/index.js").DeletionResponse>;
+    };
+    db: import("drizzle-orm/libsql").LibSQLDatabase<typeof import("./tables.js")>;
+    REST_API: {
+        tokens: {
+            get: (userId: string) => Promise<{
+                description: string | null;
+                userId: string;
+                id: string;
+                key: string;
+                creationDate: Date;
+            }[]>;
+            new: (userId: string, description: string) => Promise<{
+                description: string | null;
+                userId: string;
+                id: string;
+                key: string;
+                creationDate: Date;
+            }>;
+            delete: (userId: string, tokenId: string) => Promise<void>;
+            verify: (key: string) => Promise<false | {
+                userId: string;
+                key: string;
+                rank: string;
+            }>;
+        };
+    };
+};
+export default studioCMS_SDK;

package/dist/sdk/index.js

@@ -0,0 +1,8 @@
+import { studiocmsSDKCore } from "./core.js";
+const sdkCore = studiocmsSDKCore();
+const studioCMS_SDK = sdkCore;
+var sdk_default = studioCMS_SDK;
+export {
+  sdk_default as default,
+  studioCMS_SDK
+};

package/dist/sdk/lib/foldertree.d.ts

@@ -0,0 +1,50 @@
+import type { FolderNode, tsPageFolderSelect } from '../types/index.js';
+/**
+ * Builds a folder structure from the provided folder data.
+ *
+ * @param folders - An array of folder data to build the folder structure from.
+ * @returns An array of folder nodes representing the folder structure.
+ */
+export declare function generateFolderTree(folders: tsPageFolderSelect[]): FolderNode[];
+/**
+ * Finds a node in the tree that matches the given URL path.
+ * @param tree - The root of the folder tree.
+ * @param path - The URL path to locate.
+ * @returns The matching node or null if not found.
+ */
+export declare function findNodeByPath(tree: FolderNode[], path: string[]): FolderNode | null;
+/**
+ * Finds all nodes along the path to a specific node by its ID.
+ * @param tree - The root of the folder tree.
+ * @param id - The ID of the target node.
+ * @returns An array of nodes along the path or an empty array if the node is not found.
+ */
+export declare function findNodesAlongPathToId(tree: FolderNode[], id: string): FolderNode[];
+/**
+ * Finds the full path to a node based on its URL.
+ * @param tree - The root of the folder tree.
+ * @param path - The URL path to locate.
+ * @returns The full path as an array of node names.
+ */
+export declare function getFullPath(tree: FolderNode[], path: string[]): string[];
+/**
+ * Finds all nodes along the path to a given URL.
+ * @param tree - The root of the folder tree.
+ * @param path - The URL path to locate.
+ * @returns The nodes along the path.
+ */
+export declare function findNodesAlongPath(tree: FolderNode[], path: string[]): FolderNode[];
+/**
+ * Finds a node by its ID in the tree.
+ * @param id - The ID of the node to find.
+ * @returns The node or null if not found.
+ */
+export declare function findNodeById(tree: FolderNode[], id: string): FolderNode | null;
+/**
+ * Adds a new page to the folder tree.
+ * @param tree - The root of the folder tree.
+ * @param folderId - The ID of the parent folder.
+ * @param newPage - The new page to add.
+ * @returns The updated folder tree
+ */
+export declare function addPageToFolderTree(tree: FolderNode[], folderId: string, newPage: FolderNode): FolderNode[];

package/dist/sdk/lib/foldertree.js

@@ -0,0 +1,123 @@
+function generateFolderTree(folders) {
+  const folderMap = {};
+  for (const folder of folders) {
+    folderMap[folder.id] = {
+      id: folder.id,
+      name: folder.name,
+      pageData: null,
+      page: false,
+      children: []
+    };
+  }
+  const rootFolders = [];
+  for (const folder of folders) {
+    const childFolder = folderMap[folder.id];
+    if (!childFolder) continue;
+    if (folder.parent === null) {
+      rootFolders.push(childFolder);
+    } else {
+      const parentFolder = folderMap[folder.parent];
+      if (parentFolder) {
+        parentFolder.children.push(childFolder);
+      }
+    }
+  }
+  return rootFolders;
+}
+function findNodeByPath(tree, path) {
+  if (path.length === 0) return null;
+  const [current, ...rest] = path;
+  for (const node of tree) {
+    if (node.name === current) {
+      if (rest.length === 0) return node;
+      return findNodeByPath(node.children, rest);
+    }
+  }
+  return null;
+}
+function findNodesAlongPathToId(tree, id) {
+  const path = [];
+  function helper(nodes, targetId) {
+    for (const node of nodes) {
+      path.push(node);
+      if (node.id === targetId) {
+        return true;
+      }
+      if (helper(node.children, targetId)) {
+        return true;
+      }
+      path.pop();
+    }
+    return false;
+  }
+  helper(tree, id);
+  return path;
+}
+function getFullPath(tree, path) {
+  const result = [];
+  function helper(nodes, pathParts) {
+    if (pathParts.length === 0) return false;
+    const [current, ...rest] = pathParts;
+    for (const node of nodes) {
+      if (node.name === current) {
+        result.push(node.name);
+        if (rest.length === 0 || helper(node.children, rest)) {
+          return true;
+        }
+        result.pop();
+      }
+    }
+    return false;
+  }
+  helper(tree, path);
+  return result;
+}
+function findNodesAlongPath(tree, path) {
+  const result = [];
+  function helper(nodes, pathParts) {
+    if (pathParts.length === 0) return false;
+    const [current, ...rest] = pathParts;
+    for (const node of nodes) {
+      if (node.name === current) {
+        result.push(node);
+        if (rest.length === 0 || helper(node.children, rest)) {
+          return true;
+        }
+        result.pop();
+      }
+    }
+    return false;
+  }
+  helper(tree, path);
+  return result;
+}
+function findNodeById(tree, id) {
+  for (const node of tree) {
+    if (node.id === id) {
+      return node;
+    }
+    const found = findNodeById(node.children, id);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+function addPageToFolderTree(tree, folderId, newPage) {
+  const parentFolder = findNodeById(tree, folderId);
+  if (!parentFolder) {
+    tree.push(newPage);
+    return tree;
+  }
+  parentFolder.children.push(newPage);
+  return tree;
+}
+export {
+  addPageToFolderTree,
+  findNodeById,
+  findNodeByPath,
+  findNodesAlongPath,
+  findNodesAlongPathToId,
+  generateFolderTree,
+  getFullPath
+};

package/dist/sdk/lib/generators.d.ts

@@ -0,0 +1,30 @@
+import jwt from 'jsonwebtoken';
+/**
+ * Generates a random ID number with the specified length.
+ *
+ * @param length - The length of the random ID number to generate.
+ * @returns A random ID number with the specified length.
+ */
+export declare function generateRandomIDNumber(length: number): number;
+/**
+ * Generates a JSON Web Token (JWT) for a given user ID.
+ *
+ * @param userId - The unique identifier of the user for whom the token is being generated.
+ * @returns A signed JWT string that expires in 3 hours.
+ */
+export declare function generateToken(userId: string): string;
+/**
+ * Verifies the provided JWT token using the CMS encryption key.
+ *
+ * @param token - The JWT token to be verified.
+ * @returns The decoded token if verification is successful.
+ * @throws Will throw an error if the token is invalid or verification fails.
+ */
+export declare function testToken(token: string): string | jwt.JwtPayload;
+/**
+ * Generates a random password of the specified length.
+ *
+ * @param length - The length of the password to generate.
+ * @returns A randomly generated password string containing uppercase letters, lowercase letters, and digits.
+ */
+export declare function generateRandomPassword(length: number): string;

package/dist/sdk/lib/generators.js

@@ -0,0 +1,25 @@
+import { cmsEncryptionKey } from "virtual:studiocms/sdk/env";
+import jwt from "jsonwebtoken";
+function generateRandomIDNumber(length) {
+  return Math.floor(Math.random() * 10 ** length);
+}
+function generateToken(userId) {
+  return jwt.sign({ userId }, cmsEncryptionKey, { expiresIn: "3h" });
+}
+function testToken(token) {
+  return jwt.verify(token, cmsEncryptionKey);
+}
+function generateRandomPassword(length) {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let password = "";
+  for (let i = 0; i < length; i++) {
+    password += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return password;
+}
+export {
+  generateRandomIDNumber,
+  generateRandomPassword,
+  generateToken,
+  testToken
+};

package/dist/sdk/lib/packages.d.ts

@@ -0,0 +1,8 @@
+/**
+ * List of all page types available in the StudioCMS instance.
+ */
+export declare const pageTypeList: string[];
+/**
+ * Type of a page in the StudioCMS instance.
+ */
+export type PageType = (typeof pageTypeList)[number];

package/dist/sdk/lib/packages.js

@@ -0,0 +1,14 @@
+import pluginsList from "studiocms:plugins";
+const pageTypeList = pluginsList.flatMap(({ pageTypes }) => {
+  const pageTypeOutput = [];
+  if (!pageTypes) {
+    return pageTypeOutput;
+  }
+  for (const { identifier } of pageTypes) {
+    pageTypeOutput.push(identifier);
+  }
+  return pageTypeOutput;
+});
+export {
+  pageTypeList
+};