studiocms 0.1.0-beta.10

package/dist/sdk/StudioCMSVirtualCache.js

@@ -0,0 +1,685 @@
+import { CMSSiteConfigId, versionCacheLifetime } from "../consts.js";
+import { StudioCMSCacheError } from "./errors.js";
+class StudioCMSVirtualCache {
+  SiteConfigMapID = "__StudioCMS_Site_Config";
+  VersionMapID = "__StudioCMS_Latest_Version";
+  FolderTreeMapID = "__StudioCMS_Folder_Tree";
+  PageFolderTreeMapID = "__StudioCMS_Page_Folder_Tree";
+  FolderListMapID = "__StudioCMS_Folder_List";
+  StudioCMSPkgId = "studiocms";
+  CMSSiteConfigId = CMSSiteConfigId;
+  versionCacheLifetime = versionCacheLifetime;
+  cacheConfig;
+  sdk;
+  pages = /* @__PURE__ */ new Map();
+  siteConfig = /* @__PURE__ */ new Map();
+  version = /* @__PURE__ */ new Map();
+  folderTree = /* @__PURE__ */ new Map();
+  pageFolderTree = /* @__PURE__ */ new Map();
+  FolderList = /* @__PURE__ */ new Map();
+  cacheModule;
+  constructor(cacheConfig, sdkCore) {
+    this.cacheConfig = cacheConfig;
+    this.sdk = sdkCore;
+    this.cacheModule = {
+      GET: {
+        page: {
+          byId: async (id) => await this.getPageById(id),
+          bySlug: async (slug) => await this.getPageBySlug(slug)
+        },
+        pages: async (includeDrafts = false) => await this.getAllPages(includeDrafts),
+        siteConfig: async () => await this.getSiteConfig(),
+        latestVersion: async () => await this.getVersion(),
+        folderTree: async () => await this.getFolderTree(),
+        pageFolderTree: async (includeDrafts) => await this.getPageFolderTree(includeDrafts),
+        folderList: async () => await this.getFolderList(),
+        folder: async (id) => await this.sdk.GET.databaseEntry.folder(id)
+      },
+      CLEAR: {
+        page: {
+          byId: (id) => this.clearPageById(id),
+          bySlug: (slug) => this.clearPageBySlug(slug)
+        },
+        pages: () => this.clearAllPages(),
+        latestVersion: () => this.clearVersion(),
+        folderTree: () => this.clearFolderTree(),
+        folderList: () => this.clearFolderList()
+      },
+      UPDATE: {
+        page: {
+          byId: async (id, data) => await this.updatePageById(id, data),
+          bySlug: async (slug, data) => await this.updatePageBySlug(slug, data)
+        },
+        siteConfig: async (data) => await this.updateSiteConfig(data),
+        latestVersion: async () => await this.updateVersion(),
+        folderTree: async () => await this.updateFolderTree(),
+        folderList: async () => await this.updateFolderList(),
+        folder: async (data) => {
+          const updatedEntry = await this.sdk.UPDATE.folder(data);
+          await this.updateFolderTree();
+          await this.updateFolderList();
+          this.clearFolderTree();
+          return updatedEntry;
+        }
+      },
+      db: sdkCore.db
+    };
+  }
+  // Misc Utils
+  /**
+   * Checks if the cache entry has expired based on the provided lifetime.
+   *
+   * @param entry - The cache entry to check, which should implement the BaseCacheObject interface.
+   * @param lifetime - The lifetime duration in milliseconds. Defaults to the cacheConfig's lifetime if not provided.
+   * @returns A boolean indicating whether the cache entry has expired.
+   */
+  isCacheExpired(entry, lifetime = this.cacheConfig.lifetime) {
+    return (/* @__PURE__ */ new Date()).getTime() - entry.lastCacheUpdate.getTime() > lifetime;
+  }
+  /**
+   * Checks if the cache is enabled based on the cache configuration.
+   *
+   * @returns {boolean} True if the cache is enabled, false otherwise.
+   */
+  isEnabled() {
+    return this.cacheConfig.enabled;
+  }
+  /**
+   * Fetches the latest version of the StudioCMS package from the NPM registry.
+   *
+   * @returns {Promise<string>} A promise that resolves to the latest version string of the StudioCMS package.
+   * @throws {StudioCMSCacheError} If there is an error fetching the latest version from NPM.
+   */
+  async getLatestVersionFromNPM(pkg, ver = "latest") {
+    try {
+      const npmResponse = await fetch(`https://registry.npmjs.org/${pkg}/${ver}`);
+      const npmData = await npmResponse.json();
+      return npmData.version;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching latest version from NPM");
+    }
+  }
+  /**
+   * Generates a VersionCacheObject with the provided version and the current date as the last cache update.
+   *
+   * @param version - The version string to be included in the VersionCacheObject.
+   * @returns An object containing the provided version and the current date as the last cache update.
+   */
+  versionReturn(version) {
+    return {
+      version,
+      lastCacheUpdate: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Generates a cache object for the given site configuration.
+   *
+   * @param siteConfig - The site configuration to be cached.
+   * @returns An object containing the site configuration data and the timestamp of the cache update.
+   */
+  siteConfigReturn(siteConfig) {
+    return {
+      data: siteConfig,
+      lastCacheUpdate: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Returns a PageDataCacheObject containing the provided CombinedPageData and the current date as the last cache update.
+   *
+   * @param data - The combined page data to be cached.
+   * @returns An object containing the provided data and the current date as the last cache update.
+   */
+  pageDataReturn(data) {
+    return {
+      data,
+      lastCacheUpdate: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Returns a FolderTreeCacheObject containing the provided folder tree data and the current date as the last cache update.
+   *
+   * @param data - The folder tree data to be cached.
+   * @returns An object containing the provided data and the current date as the last cache update.
+   */
+  folderTreeReturn(data) {
+    return {
+      data,
+      lastCacheUpdate: /* @__PURE__ */ new Date()
+    };
+  }
+  folderListReturn(data) {
+    return {
+      data,
+      lastCacheUpdate: /* @__PURE__ */ new Date()
+    };
+  }
+  // Folder Tree Utils
+  async getFolderList() {
+    try {
+      if (!this.isEnabled()) {
+        const folderList = await this.sdk.getAvailableFolders();
+        if (!folderList) {
+          throw new StudioCMSCacheError("Folder list not found in database");
+        }
+        return this.folderListReturn(folderList);
+      }
+      const list = this.FolderList.get(this.FolderListMapID);
+      if (!list || this.isCacheExpired(list)) {
+        const folderList = await this.sdk.getAvailableFolders();
+        if (!folderList) {
+          throw new StudioCMSCacheError("Folder list not found in database");
+        }
+        this.FolderList.set(this.FolderListMapID, this.folderListReturn(folderList));
+        return this.folderListReturn(folderList);
+      }
+      return list;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching folder list");
+    }
+  }
+  async updateFolderList() {
+    try {
+      const folderList = await this.sdk.getAvailableFolders();
+      if (!this.isEnabled()) {
+        return this.folderListReturn(folderList);
+      }
+      this.FolderList.set(this.FolderListMapID, this.folderListReturn(folderList));
+      return this.folderListReturn(folderList);
+    } catch (error) {
+      throw new StudioCMSCacheError("Error updating folder list");
+    }
+  }
+  clearFolderList() {
+    if (!this.isEnabled()) {
+      return;
+    }
+    this.FolderList.clear();
+    return;
+  }
+  /**
+   * Retrieves the folder tree from the cache or the database.
+   *
+   * @returns {Promise<FolderTreeCacheObject>} A promise that resolves to the folder tree.
+   * @throws {StudioCMSCacheError} If the folder tree is not found in the database or if there is an error fetching the folder tree.
+   */
+  async getFolderTree() {
+    try {
+      if (!this.isEnabled()) {
+        const folderTree = await this.sdk.buildFolderTree();
+        if (!folderTree) {
+          throw new StudioCMSCacheError("Folder tree not found in database");
+        }
+        return this.folderTreeReturn(folderTree);
+      }
+      const tree = this.folderTree.get(this.FolderTreeMapID);
+      if (!tree || this.isCacheExpired(tree)) {
+        const folderTree = await this.sdk.buildFolderTree();
+        if (!folderTree) {
+          throw new StudioCMSCacheError("Folder tree not found in database");
+        }
+        this.folderTree.set(this.FolderTreeMapID, this.folderTreeReturn(folderTree));
+        return this.folderTreeReturn(folderTree);
+      }
+      return tree;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching folder tree");
+    }
+  }
+  /**
+   * Retrieves the folder tree from the cache or the database.
+   *
+   * @returns {Promise<FolderTreeCacheObject>} A promise that resolves to the folder tree.
+   * @throws {StudioCMSCacheError} If the folder tree is not found in the database or if there is an error fetching the folder tree.
+   */
+  async getPageFolderTree(includeDrafts = false) {
+    try {
+      if (!this.isEnabled()) {
+        const folderTree = await this.sdk.buildFolderTree();
+        const pages = await this.sdk.GET.database.pages(includeDrafts);
+        if (!folderTree) {
+          throw new StudioCMSCacheError("Folder tree not found in database");
+        }
+        for (const page of pages) {
+          if (!includeDrafts && page.draft) {
+            continue;
+          }
+          if (page.parentFolder) {
+            this.sdk.addPageToFolderTree(folderTree, page.parentFolder, {
+              id: page.id,
+              name: page.title,
+              page: true,
+              pageData: page,
+              children: []
+            });
+          } else {
+            folderTree.push({
+              id: page.id,
+              name: page.title,
+              page: true,
+              pageData: page,
+              children: []
+            });
+          }
+        }
+        return this.folderTreeReturn(folderTree);
+      }
+      const tree = this.pageFolderTree.get(this.PageFolderTreeMapID);
+      if (!tree || this.isCacheExpired(tree)) {
+        const folderTree = await this.sdk.buildFolderTree();
+        const pages = await this.sdk.GET.database.pages(includeDrafts);
+        if (!folderTree) {
+          throw new StudioCMSCacheError("Folder tree could not be constructed from database");
+        }
+        for (const page of pages) {
+          if (!includeDrafts && page.draft) {
+            continue;
+          }
+          if (page.parentFolder) {
+            this.sdk.addPageToFolderTree(folderTree, page.parentFolder, {
+              id: page.id,
+              name: page.title,
+              page: true,
+              pageData: page,
+              children: []
+            });
+          } else {
+            folderTree.push({
+              id: page.id,
+              name: page.title,
+              page: true,
+              pageData: page,
+              children: []
+            });
+          }
+        }
+        this.folderTree.set(this.PageFolderTreeMapID, this.folderTreeReturn(folderTree));
+        this.clearFolderTree();
+        return this.folderTreeReturn(folderTree);
+      }
+      return tree;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching folder tree");
+    }
+  }
+  /**
+   * Updates the folder tree in the cache and database.
+   *
+   * @returns {Promise<FolderTreeCacheObject>} A promise that resolves to the updated folder tree.
+   * @throws {StudioCMSCacheError} If there is an error updating the folder tree.
+   */
+  async updateFolderTree() {
+    try {
+      const folderTree = await this.sdk.buildFolderTree();
+      if (!this.isEnabled()) {
+        return this.folderTreeReturn(folderTree);
+      }
+      this.folderTree.set(this.FolderTreeMapID, this.folderTreeReturn(folderTree));
+      return this.folderTreeReturn(folderTree);
+    } catch (error) {
+      throw new StudioCMSCacheError("Error updating folder tree");
+    }
+  }
+  /**
+   * Clears the folder tree from the cache.
+   */
+  clearFolderTree() {
+    if (!this.isEnabled()) {
+      return;
+    }
+    this.folderTree.clear();
+    return;
+  }
+  // Version Utils
+  /**
+   * Retrieves the version information from the cache or fetches the latest version from NPM if the cache is disabled or expired.
+   *
+   * @returns {Promise<VersionCacheObject>} A promise that resolves to the version information object.
+   */
+  async getVersion() {
+    try {
+      if (!this.isEnabled()) {
+        const version = await this.getLatestVersionFromNPM(this.StudioCMSPkgId);
+        return this.versionReturn(version);
+      }
+      const latestVersion = this.version.get(this.VersionMapID);
+      if (!latestVersion || this.isCacheExpired(latestVersion, this.versionCacheLifetime)) {
+        const version = await this.getLatestVersionFromNPM(this.StudioCMSPkgId);
+        const latestVersion2 = this.versionReturn(version);
+        this.version.set(this.VersionMapID, latestVersion2);
+        return latestVersion2;
+      }
+      return latestVersion;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching version information");
+    }
+  }
+  /**
+   * Updates the version cache with the latest version from NPM.
+   *
+   * @returns {Promise<VersionCacheObject>} A promise that resolves to the new version cache object.
+   *
+   * @throws {Error} If there is an issue retrieving the latest version from NPM.
+   */
+  async updateVersion() {
+    try {
+      const latestVersion = await this.getLatestVersionFromNPM(this.StudioCMSPkgId);
+      const newVersion = this.versionReturn(latestVersion);
+      if (!this.isEnabled()) {
+        return newVersion;
+      }
+      this.version.set(this.VersionMapID, newVersion);
+      return newVersion;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error updating version information");
+    }
+  }
+  /**
+   * Clears the current version from the cache.
+   *
+   * This method removes all entries associated with the current version
+   * from the cache, effectively resetting it.
+   */
+  clearVersion() {
+    if (!this.isEnabled()) {
+      return;
+    }
+    this.version.clear();
+    return;
+  }
+  // Site Config Utils
+  /**
+   * Retrieves the site configuration from the cache or database.
+   *
+   * If caching is disabled, it fetches the site configuration directly from the database.
+   * If caching is enabled, it first checks the cache for the site configuration. If the cache is expired or not found,
+   * it fetches the site configuration from the database, updates the cache, and returns the configuration.
+   *
+   * @returns {Promise<SiteConfigCacheObject>} A promise that resolves to the site configuration object.
+   * @throws {StudioCMSCacheError} If the site configuration is not found in the database.
+   */
+  async getSiteConfig() {
+    try {
+      if (!this.isEnabled()) {
+        const newSiteConfig = await this.sdk.GET.database.config();
+        if (!newSiteConfig) {
+          throw new StudioCMSCacheError("Site config not found in database");
+        }
+        return this.siteConfigReturn(newSiteConfig);
+      }
+      const siteConfig = this.siteConfig.get(this.SiteConfigMapID);
+      if (!siteConfig || this.isCacheExpired(siteConfig)) {
+        const newSiteConfig = await this.sdk.GET.database.config();
+        if (!newSiteConfig) {
+          throw new StudioCMSCacheError("Site config not found in database");
+        }
+        const returnConfig = this.siteConfigReturn(newSiteConfig);
+        this.siteConfig.set(this.SiteConfigMapID, returnConfig);
+        return returnConfig;
+      }
+      return siteConfig;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching site configuration", error.stack);
+    }
+  }
+  /**
+   * Updates the site configuration in the database and cache.
+   *
+   * @param data - The new site configuration data to be updated.
+   * @returns A promise that resolves to the updated site configuration cache object.
+   * @throws {StudioCMSCacheError} If the updated data could not be retrieved from the database.
+   */
+  async updateSiteConfig(data) {
+    try {
+      const newSiteConfig = await this.sdk.UPDATE.siteConfig({ ...data, id: this.CMSSiteConfigId });
+      if (!newSiteConfig) {
+        throw new StudioCMSCacheError("Could not retrieve updated data from the database.");
+      }
+      const returnConfig = this.siteConfigReturn(newSiteConfig);
+      if (!this.isEnabled()) {
+        return returnConfig;
+      }
+      this.siteConfig.set(this.SiteConfigMapID, returnConfig);
+      return returnConfig;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error updating site configuration");
+    }
+  }
+  // Page Utils
+  /**
+   * Clear a page from the cache by its ID
+   * @param id - The ID of the page
+   *
+   * @returns void
+   */
+  clearPageById(id) {
+    if (!this.isEnabled()) {
+      return;
+    }
+    this.pages.delete(id);
+    return;
+  }
+  /**
+   * Clear a page from the cache by its slug and package
+   * @param slug - The slug of the page
+   * @param pkg - The package of the page
+   *
+   * @returns void
+   */
+  clearPageBySlug(slug) {
+    if (!this.isEnabled()) {
+      return;
+    }
+    const keyIndex = [];
+    for (const [key, cachedObject] of this.pages) {
+      if (cachedObject.data.slug === slug) {
+        keyIndex.push(key);
+      }
+    }
+    for (const key of keyIndex) {
+      this.pages.delete(key);
+    }
+    return;
+  }
+  /**
+   * Clear all pages from the cache
+   *
+   * @returns void
+   */
+  clearAllPages() {
+    if (!this.isEnabled()) {
+      return;
+    }
+    this.pages.clear();
+    return;
+  }
+  /**
+   * Retrieves all pages from the cache or the database.
+   *
+   * @returns {Promise<PageDataCacheObject[]>} A promise that resolves to an array of page data cache objects.
+   *
+   * @throws {StudioCMS_SDK_Error} If the cache is empty and could not be updated, or if the cache is expired and could not be updated.
+   *
+   * @remarks
+   * - If caching is disabled, the data is retrieved directly from the database.
+   * - If the cache is empty, the data is retrieved from the database and stored in the cache.
+   * - If the cache contains data, it checks for expired entries and updates them from the database if necessary.
+   */
+  async getAllPages(includeDrafts = false) {
+    try {
+      if (!this.isEnabled()) {
+        const pages = await this.sdk.GET.database.pages(includeDrafts);
+        return pages.map((page) => this.pageDataReturn(page));
+      }
+      const { data: tree } = await this.getFolderTree();
+      if (this.pages.size === 0) {
+        const updatedData = await this.sdk.GET.database.pages(includeDrafts, tree);
+        if (!updatedData) {
+          throw new StudioCMSCacheError("Cache is empty and could not be updated.");
+        }
+        for (const data of updatedData) {
+          this.pages.set(data.id, this.pageDataReturn(data));
+        }
+        return updatedData.map((data) => this.pageDataReturn(data));
+      }
+      const cacheMap = Array.from(this.pages.values());
+      for (const object of cacheMap) {
+        if (this.isCacheExpired(object)) {
+          const updatedData = await this.sdk.GET.databaseEntry.pages.byId(object.data.id, tree);
+          if (!updatedData) {
+            throw new StudioCMSCacheError("Cache is expired and could not be updated.");
+          }
+          this.pages.set(updatedData.id, this.pageDataReturn(updatedData));
+        }
+      }
+      return Array.from(this.pages.values());
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching all pages");
+    }
+  }
+  /**
+   * Retrieves a page by its ID, either from the cache or the database.
+   *
+   * @param {string} id - The ID of the page to retrieve.
+   * @returns {Promise<PageDataCacheObject>} - A promise that resolves to the page data.
+   * @throws {StudioCMSCacheError} - Throws an error if the page is not found in the database or if there is an error fetching the page.
+   */
+  async getPageById(id) {
+    try {
+      if (!this.isEnabled()) {
+        const page = await this.sdk.GET.databaseEntry.pages.byId(id);
+        if (!page) {
+          throw new StudioCMSCacheError("Page not found in database");
+        }
+        return this.pageDataReturn(page);
+      }
+      const { data: tree } = await this.getFolderTree();
+      const cachedPage = this.pages.get(id);
+      if (!cachedPage || this.isCacheExpired(cachedPage)) {
+        const page = await this.sdk.GET.databaseEntry.pages.byId(id, tree);
+        if (!page) {
+          throw new StudioCMSCacheError("Page not found in database");
+        }
+        const returnPage = this.pageDataReturn(page);
+        this.pages.set(id, returnPage);
+        return returnPage;
+      }
+      return cachedPage;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching page by ID");
+    }
+  }
+  /**
+   * Retrieves a page by its slug from the cache or database.
+   *
+   * @param {string} slug - The slug of the page to retrieve.
+   * @returns {Promise<PageDataCacheObject>} A promise that resolves to the page data.
+   * @throws {StudioCMSCacheError} If the page is not found in the database or if there is an error fetching the page.
+   */
+  async getPageBySlug(slug) {
+    try {
+      if (!this.isEnabled()) {
+        const page = await this.sdk.GET.databaseEntry.pages.bySlug(slug);
+        if (!page) {
+          throw new StudioCMSCacheError("Page not found in database");
+        }
+        return this.pageDataReturn(page);
+      }
+      const { data: tree } = await this.getFolderTree();
+      const cachedPage = Array.from(this.pages.values()).find((page) => page.data.slug === slug);
+      if (!cachedPage || this.isCacheExpired(cachedPage)) {
+        const page = await this.sdk.GET.databaseEntry.pages.bySlug(slug, tree);
+        if (!page) {
+          throw new StudioCMSCacheError("Page not found in database");
+        }
+        const returnPage = this.pageDataReturn(page);
+        this.pages.set(page.id, returnPage);
+        return returnPage;
+      }
+      return cachedPage;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error fetching page by slug");
+    }
+  }
+  /**
+   * Updates a page by its ID with the provided data.
+   *
+   * @param id - The ID of the page to update.
+   * @param data - An object containing the page data and page content to update.
+   * @param data.pageData - The data of the page to update.
+   * @param data.pageContent - The content of the page to update.
+   * @returns A promise that resolves to the updated page data cache object.
+   * @throws {StudioCMSCacheError} If the page is not found in the database or if there is an error updating the page.
+   */
+  async updatePageById(id, data) {
+    try {
+      if (!this.isEnabled()) {
+        await this.sdk.UPDATE.page(data.pageData);
+        await this.sdk.UPDATE.pageContent(data.pageContent);
+        const updatedData2 = await this.sdk.GET.databaseEntry.pages.byId(id);
+        if (!updatedData2) {
+          throw new StudioCMSCacheError("Page not found in database");
+        }
+        return this.pageDataReturn(updatedData2);
+      }
+      const { data: tree } = await this.updateFolderTree();
+      await this.sdk.UPDATE.page(data.pageData);
+      await this.sdk.UPDATE.pageContent(data.pageContent);
+      const updatedData = await this.sdk.GET.databaseEntry.pages.byId(id, tree);
+      if (!updatedData) {
+        throw new StudioCMSCacheError("Page not found in database");
+      }
+      const returnData = this.pageDataReturn(updatedData);
+      this.pages.set(id, returnData);
+      this.clearFolderTree();
+      return returnData;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error updating page by ID");
+    }
+  }
+  /**
+   * Updates a page by its slug and package name.
+   *
+   * @param slug - The slug of the page to update.
+   * @param pkg - The package name of the page to update.
+   * @param data - An object containing the page data and page content to update.
+   * @param data.pageData - The data of the page to update.
+   * @param data.pageContent - The content of the page to update.
+   * @returns A promise that resolves to the updated page data cache object.
+   * @throws {StudioCMSCacheError} If the page is not found in the cache or database, or if there is an error updating the page.
+   */
+  async updatePageBySlug(slug, data) {
+    try {
+      if (!this.isEnabled()) {
+        await this.sdk.UPDATE.page(data.pageData);
+        await this.sdk.UPDATE.pageContent(data.pageContent);
+        const updatedData2 = await this.sdk.GET.databaseEntry.pages.bySlug(slug);
+        if (!updatedData2) {
+          throw new StudioCMSCacheError("Page not found in database");
+        }
+        return this.pageDataReturn(updatedData2);
+      }
+      const { data: tree } = await this.updateFolderTree();
+      const cachedPage = Array.from(this.pages.values()).find((page) => page.data.slug === slug);
+      if (!cachedPage) {
+        throw new StudioCMSCacheError("Page not found in cache");
+      }
+      await this.sdk.UPDATE.page(data.pageData);
+      await this.sdk.UPDATE.pageContent(data.pageContent);
+      const updatedData = await this.sdk.GET.databaseEntry.pages.bySlug(slug, tree);
+      if (!updatedData) {
+        throw new StudioCMSCacheError("Page not found in database");
+      }
+      const returnData = this.pageDataReturn(updatedData);
+      this.pages.set(updatedData.id, returnData);
+      this.clearFolderTree();
+      return returnData;
+    } catch (error) {
+      throw new StudioCMSCacheError("Error updating page by slug");
+    }
+  }
+}
+var StudioCMSVirtualCache_default = StudioCMSVirtualCache;
+export {
+  StudioCMSVirtualCache,
+  StudioCMSVirtualCache_default as default
+};

package/dist/sdk/cache.d.ts

@@ -0,0 +1,11 @@
+import type { PageDataCacheObject, STUDIOCMS_SDK_CACHE, SiteConfigCacheObject, VersionCacheObject } from './types/index.js';
+export type { STUDIOCMS_SDK_CACHE, PageDataCacheObject, SiteConfigCacheObject, VersionCacheObject };
+/**
+ * A constant representing the StudioCMS SDK Cache.
+ * This cache is used to store and retrieve data within the StudioCMS SDK.
+ *
+ * @constant
+ * @type {STUDIOCMS_SDK_CACHE}
+ */
+export declare const studioCMS_SDK_Cache: STUDIOCMS_SDK_CACHE;
+export default studioCMS_SDK_Cache;