studiocms 0.1.0-beta.7 → 0.1.0-beta.8

package/dist/sdk/StudioCMSVirtualCache.d.ts

@@ -0,0 +1,283 @@
+import type { studiocmsSDKCore } from './core.js';
+import type { FolderListCacheObject, FolderTreeCacheObject, PageDataCacheObject, ProcessedCacheConfig, SiteConfig, SiteConfigCacheObject, VersionCacheObject, tsPageContentSelect, tsPageDataSelect, tsPageFolderSelect } from './types/index.js';
+import type { useDB } from './utils/db.js';
+/**
+ * The `StudioCMSVirtualCache` class provides caching utilities for the StudioCMS SDK.
+ * It supports caching for site configurations, versions, and page data.
+ *
+ * @class
+ * @classdesc This class handles caching operations for the StudioCMS SDK, including
+ * fetching, updating, and clearing cache entries for site configurations, versions,
+ * and page data.
+ *
+ * @param {ProcessedCacheConfig} cacheConfig - The configuration for the cache.
+ * @param {STUDIOCMS_SDK} studioCMS_SDK - The StudioCMS SDK instance.
+ */
+export declare class StudioCMSVirtualCache {
+    private readonly SiteConfigMapID;
+    private readonly VersionMapID;
+    private readonly FolderTreeMapID;
+    private readonly PageFolderTreeMapID;
+    private readonly FolderListMapID;
+    private readonly StudioCMSPkgId;
+    private readonly CMSSiteConfigId;
+    private readonly versionCacheLifetime;
+    private readonly cacheConfig;
+    private readonly sdk;
+    private pages;
+    private siteConfig;
+    private version;
+    private folderTree;
+    private pageFolderTree;
+    private FolderList;
+    cacheModule: {
+        GET: {
+            page: {
+                byId: (id: string) => Promise<PageDataCacheObject>;
+                bySlug: (slug: string) => Promise<PageDataCacheObject>;
+            };
+            pages: (includeDrafts?: boolean) => Promise<PageDataCacheObject[]>;
+            siteConfig: () => Promise<SiteConfigCacheObject>;
+            latestVersion: () => Promise<VersionCacheObject>;
+            folderTree: () => Promise<FolderTreeCacheObject>;
+            pageFolderTree: (includeDrafts?: boolean) => Promise<FolderTreeCacheObject>;
+            folderList: () => Promise<FolderListCacheObject>;
+            folder: (id: string) => Promise<{
+                name: string;
+                id: string;
+                parent: string | null;
+            } | undefined>;
+        };
+        CLEAR: {
+            page: {
+                byId: (id: string) => void;
+                bySlug: (slug: string) => void;
+            };
+            pages: () => void;
+            latestVersion: () => void;
+            folderTree: () => void;
+            folderList: () => void;
+        };
+        UPDATE: {
+            page: {
+                byId: (id: string, data: {
+                    pageData: tsPageDataSelect;
+                    pageContent: tsPageContentSelect;
+                }) => Promise<PageDataCacheObject>;
+                bySlug: (slug: string, data: {
+                    pageData: tsPageDataSelect;
+                    pageContent: tsPageContentSelect;
+                }) => Promise<PageDataCacheObject>;
+            };
+            siteConfig: (data: SiteConfig) => Promise<SiteConfigCacheObject>;
+            latestVersion: () => Promise<VersionCacheObject>;
+            folderTree: () => Promise<FolderTreeCacheObject>;
+            folderList: () => Promise<FolderListCacheObject>;
+            folder: (data: tsPageFolderSelect) => Promise<{
+                name: string;
+                id: string;
+                parent: string | null;
+            }>;
+        };
+        db: ReturnType<typeof useDB>;
+    };
+    constructor(cacheConfig: ProcessedCacheConfig, sdkCore: ReturnType<typeof studiocmsSDKCore>);
+    /**
+     * 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.
+     */
+    private isCacheExpired;
+    /**
+     * Checks if the cache is enabled based on the cache configuration.
+     *
+     * @returns {boolean} True if the cache is enabled, false otherwise.
+     */
+    private isEnabled;
+    /**
+     * 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.
+     */
+    private getLatestVersionFromNPM;
+    /**
+     * 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.
+     */
+    private versionReturn;
+    /**
+     * 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.
+     */
+    private siteConfigReturn;
+    /**
+     * 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.
+     */
+    private pageDataReturn;
+    /**
+     * 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.
+     */
+    private folderTreeReturn;
+    private folderListReturn;
+    getFolderList(): Promise<FolderListCacheObject>;
+    updateFolderList(): Promise<FolderListCacheObject>;
+    clearFolderList(): void;
+    /**
+     * 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.
+     */
+    getFolderTree(): Promise<FolderTreeCacheObject>;
+    /**
+     * 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.
+     */
+    getPageFolderTree(includeDrafts?: boolean): Promise<FolderTreeCacheObject>;
+    /**
+     * 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.
+     */
+    updateFolderTree(): Promise<FolderTreeCacheObject>;
+    /**
+     * Clears the folder tree from the cache.
+     */
+    clearFolderTree(): void;
+    /**
+     * 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.
+     */
+    getVersion(): Promise<VersionCacheObject>;
+    /**
+     * 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.
+     */
+    updateVersion(): Promise<VersionCacheObject>;
+    /**
+     * Clears the current version from the cache.
+     *
+     * This method removes all entries associated with the current version
+     * from the cache, effectively resetting it.
+     */
+    clearVersion(): void;
+    /**
+     * 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.
+     */
+    getSiteConfig(): Promise<SiteConfigCacheObject>;
+    /**
+     * 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.
+     */
+    updateSiteConfig(data: SiteConfig): Promise<SiteConfigCacheObject>;
+    /**
+     * Clear a page from the cache by its ID
+     * @param id - The ID of the page
+     *
+     * @returns void
+     */
+    clearPageById(id: string): void;
+    /**
+     * 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: string): void;
+    /**
+     * Clear all pages from the cache
+     *
+     * @returns void
+     */
+    clearAllPages(): void;
+    /**
+     * 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.
+     */
+    getAllPages(includeDrafts?: boolean): Promise<PageDataCacheObject[]>;
+    /**
+     * 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.
+     */
+    getPageById(id: string): Promise<PageDataCacheObject>;
+    /**
+     * 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.
+     */
+    getPageBySlug(slug: string): Promise<PageDataCacheObject>;
+    /**
+     * 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.
+     */
+    updatePageById(id: string, data: {
+        pageData: tsPageDataSelect;
+        pageContent: tsPageContentSelect;
+    }): Promise<PageDataCacheObject>;
+    /**
+     * 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.
+     */
+    updatePageBySlug(slug: string, data: {
+        pageData: tsPageDataSelect;
+        pageContent: tsPageContentSelect;
+    }): Promise<PageDataCacheObject>;
+}
+export default StudioCMSVirtualCache;