nextjs-cms 0.5.56 → 0.5.58

package/dist/core/factories/section-factory-with-jiti.js

@@ -0,0 +1,556 @@
+import { glob } from 'glob';
+import { cloneDeep } from 'lodash-es';
+import { resolve } from 'path';
+import chalk from 'chalk';
+import { eq } from 'drizzle-orm';
+import chokidar from 'chokidar';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { db } from '../../db/client.js';
+import { AdminPrivilegesTable } from '../../db/schema.js';
+import { getCMSConfig, getConfigImportVersion } from '../config/index.js';
+const hotMarkerFile = resolve(process.cwd(), 'components/form/helpers/_section-hot-reload.js');
+// Create a require function that works in ES modules
+const safeRequire = createRequire(import.meta.url);
+/**
+ * Load jiti via Node require so Next can externalize it and avoid <dynamic> bundler errors.
+ */
+const loadJiti = () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const jitiModule = safeRequire('jiti');
+    return jitiModule.createJiti;
+};
+/**
+ * Global jiti instance for loading section modules.
+ * We keep it global so we can clear its cache when files change.
+ */
+let jitiInstance = null;
+let cachedCmsConfig = null;
+let cachedCmsConfigVersion = -1;
+const getCmsConfigCached = async (currentVersion = getConfigImportVersion()) => {
+    if (!cachedCmsConfig || cachedCmsConfigVersion !== currentVersion) {
+        cachedCmsConfig = await getCMSConfig();
+        cachedCmsConfigVersion = currentVersion;
+    }
+    return cachedCmsConfig;
+};
+/**
+ * Log a message to the console if debug mode is enabled
+ * @param args - The arguments to log
+ * @returns void
+ */
+const log = (...args) => {
+    if (!cachedCmsConfig?.debug)
+        return;
+    console.log(chalk.black.bgGreen(`[${new Date().toISOString()}][next-cms-debug]`, ...args));
+};
+const getJitiInstance = () => {
+    if (!jitiInstance) {
+        const createJiti = loadJiti();
+        jitiInstance = createJiti(import.meta.url, {
+            // Keep your previous behavior:
+            // - return default export compatibly
+            interopDefault: true,
+            // Caching (new API uses fsCache/moduleCache)
+            // Keep them enabled for better performance.
+            fsCache: true,
+            moduleCache: true,
+            rebuildFsCache: true,
+            // Optional: nicer debugging in stack traces (off by default in jiti)
+            // sourceMaps: true,
+        });
+    }
+    return jitiInstance;
+};
+/**
+ * Clear jiti's cache for a specific file path.
+ * This ensures that when a file changes, jiti will reload it on the next require.
+ */
+const clearJitiCache = (absPath) => {
+    const jiti = getJitiInstance();
+    try {
+        // Try to resolve the path using jiti's resolve (which handles TS files)
+        let resolvedPath;
+        try {
+            // jiti extends NodeRequire, so it has resolve
+            resolvedPath = jiti.resolve(absPath);
+        }
+        catch {
+            // Last resort: use the absPath as-is
+            resolvedPath = absPath;
+        }
+        // Clear from jiti's cache (jiti extends NodeRequire, so it has cache)
+        if (resolvedPath && jiti.cache[resolvedPath]) {
+            delete jiti.cache[resolvedPath];
+            log('Cleared jiti cache for', resolvedPath);
+        }
+        // Also clear from Node's global require cache (for safety)
+        if (resolvedPath && safeRequire.cache[resolvedPath]) {
+            delete safeRequire.cache[resolvedPath];
+            log('Cleared Node require cache for', resolvedPath);
+        }
+        // Try clearing with .ts extension if different
+        const tsPath = absPath.endsWith('.ts') ? absPath : `${absPath}.ts`;
+        if (tsPath !== resolvedPath && jiti.cache[tsPath]) {
+            delete jiti.cache[tsPath];
+            log('Cleared jiti cache for', tsPath);
+        }
+        if (tsPath !== resolvedPath && safeRequire.cache[tsPath]) {
+            delete safeRequire.cache[tsPath];
+            log('Cleared Node require cache for', tsPath);
+        }
+    }
+    catch (err) {
+        // If resolution fails, try clearing by matching keys in cache
+        log('Could not resolve path for cache clearing, trying pattern match:', absPath);
+        const absPathNormalized = absPath.replace(/\\/g, '/');
+        // Clear any cache entries that match this path
+        for (const key in jiti.cache) {
+            if (key.replace(/\\/g, '/').includes(absPathNormalized)) {
+                delete jiti.cache[key];
+                log('Cleared jiti cache entry:', key);
+            }
+        }
+        for (const key in safeRequire.cache) {
+            if (key.replace(/\\/g, '/').includes(absPathNormalized)) {
+                delete safeRequire.cache[key];
+                log('Cleared Node require cache entry:', key);
+            }
+        }
+    }
+};
+const loadSectionModuleRuntime = async (absPath) => {
+    const jiti = getJitiInstance();
+    /**
+     * We're using the deprecated synchronous API because
+     * it works with Turbopack, the new jiti.import() does not.
+     */
+    const mod = jiti(absPath);
+    return mod?.default ?? mod;
+};
+export class SectionFactory {
+    /**
+     * These are the fixed sections that can not be present in the sections folder.
+     */
+    static fixedSections = ['admins', 'analytics', 'emails', 'dashboard'];
+    static isDev = process.env.NODE_ENV !== 'production';
+    static isProd = !this.isDev;
+    static sectionProcessingErrors = {};
+    static sectionFetchingErrors = {};
+    static errorCount = 0;
+    /**
+     * Global in-process cache for all section configs.
+     * Populated once per Node process via loadAllSections(),
+     * reused by all get*() calls until the process is restarted,
+     * so all subsequent calls reuse this array.
+     */
+    static allSectionsPromise = null;
+    static allSectionsLoaded = false;
+    static watcherStarted = false;
+    static configVersion = -1;
+    static sectionWatcher = null;
+    static async ensureConfigFresh() {
+        const currentVersion = getConfigImportVersion();
+        const cmsConfig = await getCmsConfigCached(currentVersion);
+        if (this.configVersion !== currentVersion) {
+            this.configVersion = currentVersion;
+            this.sectionProcessingErrors = {};
+            this.sectionFetchingErrors = {};
+            this.errorCount = 0;
+            this.allSectionsPromise = null;
+            this.allSectionsLoaded = false;
+            if (this.sectionWatcher) {
+                await this.sectionWatcher.close();
+                this.sectionWatcher = null;
+                this.watcherStarted = false;
+            }
+        }
+        return cmsConfig;
+    }
+    static bumpHotMarker() {
+        if (!SectionFactory.isDev)
+            return;
+        const content = `/**\n` +
+            ` * AUTO-GENERATED. DO NOT EDIT.\n` +
+            ` * This file is used to track the last time the sections/config schema was updated.\n` +
+            ` * It is used to trigger a hot reload of the section/config in development mode.\n` +
+            ` */\n` +
+            `\n` +
+            `export const revalidate = 0\n` +
+            `\n` +
+            `// @refresh reset\n` +
+            `\n` +
+            `export const configLastUpdated = ${Date.now()}\n`;
+        try {
+            fs.writeFileSync(hotMarkerFile, content, 'utf8');
+            log('Bumped _section-hot-reload.js to trigger Next Fast Refresh');
+        }
+        catch (err) {
+            console.error('Failed to bump _section-hot-reload.js:', err);
+        }
+    }
+    // ---------- PUBLIC API ----------
+    /**
+     * Get all sections
+     * @param type - The type of sections to get
+     * @returns The sections
+     */
+    static async getSections(type) {
+        return await this.get({ type });
+    }
+    /**
+     * Get all accessible sections for an admin
+     * @param type - The type of section to get
+     * @param admin - The admin to get the sections for
+     * @returns The sections for the admin
+     */
+    static async getSectionsForAdmin({ type, admin, }) {
+        const sections = await this.get({ type, admin });
+        const privileges = await db
+            .select({
+            sectionName: AdminPrivilegesTable.sectionName,
+            operations: AdminPrivilegesTable.operations,
+        })
+            .from(AdminPrivilegesTable)
+            .where(eq(AdminPrivilegesTable.adminId, admin.id));
+        const fixedSections = privileges
+            .filter((privilege) => this.fixedSections.includes(privilege.sectionName))
+            .map((privilege) => privilege.sectionName);
+        const simpleSections = sections.filter((section) => section.type === 'simple');
+        const hasItemsSections = sections.filter((section) => section.type === 'has_items');
+        const categorySections = sections.filter((section) => section.type === 'category');
+        return {
+            simple: simpleSections,
+            has_items: hasItemsSections,
+            category: categorySections,
+            fixed: fixedSections,
+        };
+    }
+    /**
+     * Get a section
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @returns The section
+     */
+    static async getSection({ name, type, }) {
+        const section = await this.get({ name, type });
+        return section[0] ? section[0] : null;
+    }
+    /**
+     * Get an accessible section for an admin
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @param admin - The admin to get the section for
+     * @returns The section for the admin
+     */
+    static async getSectionForAdmin({ name, type, admin, }) {
+        const section = await this.get({ type, admin, name });
+        return section[0] ? section[0] : null;
+    }
+    /**
+     * Create a Section instance from a section config
+     * The config must have a build() method (created via helper functions like simpleSection(), hasItemsSection(), etc.)
+     *
+     * Note: This factory only accepts configs. If you already have a Section instance,
+     * use it directly - don't pass it to this factory.
+     *
+     * @param config - A section config object with a build() method
+     * @returns A Section instance
+     * @throws Error if config doesn't have a build() method
+     */
+    static create(config) {
+        if (typeof config.build === 'function') {
+            return config.build();
+        }
+        throw new Error('Section config must have a build() method. Use helper functions like simpleSection(), hasItemsSection(), categorySection() to create configs.');
+    }
+    // ---------- INTERNAL CORE ----------
+    /**
+     * Return a clone of the section(s) info to get a fresh copy of the section(s).
+     * Not cloning will cause the original section(s) (in *.section.ts file) to be modified!
+     * Each *.section.ts file must have exactly one default export (arrays are not allowed).
+     *
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @param admin - The admin to get the section for
+     * @returns The section(s)
+     */
+    static async get({ name, type, admin, }) {
+        try {
+            const allSections = await this.loadAllSections();
+            /**
+             * Always show errors if there are any.
+             * This is to make sure the errors are shown on every request (technically, every time the section is requested).
+             * This way devs can notice the errors and fix them.
+             */
+            if (this.errorCount > 0) {
+                console.log(`\n${chalk.bgRed.bold(` Errors while fetching sections `)}${chalk.red.bold('-------')}\n`);
+                if (Object.keys(this.sectionProcessingErrors).length > 0) {
+                    console.log(`${chalk.bold.redBright(`Processing errors:`)}`);
+                    for (const [file, errors] of Object.entries(this.sectionProcessingErrors)) {
+                        console.log('');
+                        console.log(chalk.bold(`[${file}]:`));
+                        for (const error of errors) {
+                            console.error(error);
+                        }
+                        console.log('');
+                    }
+                }
+                if (Object.keys(this.sectionFetchingErrors).length > 0) {
+                    console.log(`\n${chalk.bold.redBright(`Importing errors:`)}`);
+                    for (const [file, errors] of Object.entries(this.sectionFetchingErrors)) {
+                        console.log('');
+                        console.log(chalk.bold(`[${file}]:`));
+                        for (const error of errors) {
+                            console.error(error);
+                        }
+                        console.log('');
+                    }
+                }
+                console.log(`${chalk.red.bold('-------')}`);
+            }
+            const types = type
+                ? Array.isArray(type)
+                    ? type
+                    : [type]
+                : ['has_items', 'simple', 'category'];
+            // Filter by type first
+            let filtered = allSections.filter((section) => types.includes(section.type));
+            // If admin is provided, restrict to privileged sections
+            if (admin && admin.id) {
+                const privileges = await db
+                    .select({
+                    sectionName: AdminPrivilegesTable.sectionName,
+                    operations: AdminPrivilegesTable.operations,
+                })
+                    .from(AdminPrivilegesTable)
+                    .where(eq(AdminPrivilegesTable.adminId, admin.id));
+                const privilegedSections = [];
+                privileges.forEach((privilege) => {
+                    if (admin.requiredRole) {
+                        if (privilege.operations.includes(admin.requiredRole)) {
+                            privilegedSections.push(privilege.sectionName);
+                        }
+                    }
+                    else {
+                        privilegedSections.push(privilege.sectionName);
+                    }
+                });
+                filtered = filtered.filter((section) => privilegedSections.includes(section.name));
+            }
+            if (name) {
+                const found = filtered.find((section) => section.name === name);
+                return found ? [cloneDeep(found)] : [];
+            }
+            return filtered.map((section) => cloneDeep(section));
+        }
+        catch (err) {
+            console.error('Error loading section configs:', err);
+            return [];
+        }
+    }
+    /**
+     * Load all *.section.ts files once, import their default exports,
+     * and cache the resulting configs for the lifetime of the process
+     * (until invalidated in dev by file changes).
+     */
+    static async loadAllSections() {
+        const cmsConfig = await this.ensureConfigFresh();
+        if (this.allSectionsPromise)
+            return this.allSectionsPromise;
+        if (this.isDev) {
+            // In dev, watch for changes and reload on demand
+            // This will lazy load on first get() as well
+            this.startWatcher(cmsConfig);
+        }
+        this.allSectionsPromise = (async () => {
+            if (!this.allSectionsLoaded) {
+                log('Loading all sections from disk...', this.isDev ? '(dev mode)' : '(production mode)');
+            }
+            const sections = [];
+            try {
+                const sectionFiles = await glob('**/*.section.ts', {
+                    cwd: cmsConfig.sections.path,
+                });
+                for (const file of sectionFiles) {
+                    try {
+                        const absPath = resolve(cmsConfig.sections.path, file);
+                        const defaultExport = await loadSectionModuleRuntime(absPath);
+                        if (!defaultExport) {
+                            if (!this.sectionFetchingErrors[file]) {
+                                this.sectionFetchingErrors[file] = [];
+                            }
+                            this.sectionFetchingErrors[file].push(chalk.rgb(255, 100, 0)('Section file must have a default export. Skipping.'));
+                            this.errorCount++;
+                            continue;
+                        }
+                        if (Array.isArray(defaultExport)) {
+                            if (!this.sectionFetchingErrors[file]) {
+                                this.sectionFetchingErrors[file] = [];
+                            }
+                            this.sectionFetchingErrors[file].push(chalk.rgb(255, 100, 0)('Section file exports an array. Each file must export exactly one section. Skipping.'));
+                            this.errorCount++;
+                            continue;
+                        }
+                        if (!defaultExport.type || !defaultExport.name) {
+                            if (!this.sectionFetchingErrors[file]) {
+                                this.sectionFetchingErrors[file] = [];
+                            }
+                            this.sectionFetchingErrors[file].push(chalk.rgb(255, 100, 0)('Section file default export must have "type" and "name". Skipping.'));
+                            this.errorCount++;
+                            continue;
+                        }
+                        sections.push(defaultExport);
+                    }
+                    catch (importErr) {
+                        /**
+                         * Guardrail: extensioned imports inside section files
+                         * This usually means the developer wrote:
+                         *   import x from './other.section.ts'
+                         * or './other.section.js'
+                         * which breaks once sections are bundled.
+                         */
+                        if (importErr instanceof Error &&
+                            importErr.message.includes('Cannot find module') &&
+                            importErr.message.includes('.section')) {
+                            this.sectionProcessingErrors[file] ??= [];
+                            this.sectionProcessingErrors[file].push(`❌ Invalid section import detected.
+
+Sections MUST use extensionless relative imports:
+
+  ✅ import exampleSection from './example.section'
+  ❌ import exampleSection from './example.section.ts'
+  ❌ import exampleSection from './example.section.js'
+
+This file is bundled with esbuild, so Node never resolves the import directly.
+If you added an extension manually, remove it.`);
+                            this.errorCount++;
+                            continue;
+                        }
+                        /**
+                         * Normal error handling
+                         * Only display the error message, not the stack trace.
+                         */
+                        if (importErr instanceof Error) {
+                            /**
+                             * Only display the error message, not the stack trace.
+                             */
+                            if (!this.sectionProcessingErrors[file]) {
+                                this.sectionProcessingErrors[file] = [];
+                            }
+                            this.sectionProcessingErrors[file].push(importErr.message);
+                        }
+                        else {
+                            if (!this.sectionFetchingErrors[file]) {
+                                this.sectionFetchingErrors[file] = [];
+                            }
+                            this.sectionFetchingErrors[file].push(chalk.rgb(255, 100, 0)(`Unknown error type: ${typeof importErr}`));
+                            throw new Error(`${chalk.bgRed(` Error importing ${file}: `)}, ${importErr}`);
+                        }
+                        this.errorCount++;
+                        /**
+                         * Tests-only:
+                         * remove from require cache so it will be reloaded next time.
+                         * In dev/runtime, cache busting is handled via versioned ESM imports.
+                         */
+                        if (process.env.NODE_ENV === 'test') {
+                            try {
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                delete safeRequire.cache?.[resolve(cmsConfig.sections.path, file)];
+                            }
+                            catch {
+                                // ignore
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.error('Error finding section files:', err);
+            }
+            this.allSectionsLoaded = true;
+            /**
+             * If `strict` mode is enabled,
+             * don't return sections if there are errors.
+             */
+            if (cmsConfig.sections.strict && this.errorCount > 0) {
+                return [];
+            }
+            log(`Loaded ${sections.length} section(s)`);
+            return sections;
+        })();
+        return this.allSectionsPromise;
+    }
+    // ---------- DEV WATCHER & CACHE INVALIDATION ----------
+    static startWatcher(cmsConfig) {
+        if (!this.isDev || this.watcherStarted)
+            return;
+        this.watcherStarted = true;
+        const watcher = chokidar.watch('**/*.section.ts', {
+            cwd: cmsConfig.sections.path,
+            ignoreInitial: true,
+        });
+        this.sectionWatcher = watcher;
+        log('Starting section watcher in dev mode...');
+        /**
+         * Invalidate section cache + bust runtime import cache.
+         * When a section file changes, we need to:
+         * 1. Clear jiti's module cache for that file
+         * 2. Reset our in-process caches
+         * 3. Reset the promise so sections reload on next access
+         * 4. Bump the hot marker to trigger Next.js Fast Refresh
+         */
+        const invalidateForRelPath = (relPath) => {
+            const absPath = resolve(cmsConfig.sections.path, relPath);
+            // Clear jiti's cache for the changed file
+            clearJitiCache(absPath);
+            // Also clear the require cache for the hot marker file (if it exists)
+            try {
+                const jiti = getJitiInstance();
+                if (jiti.cache[hotMarkerFile]) {
+                    delete jiti.cache[hotMarkerFile];
+                }
+                if (safeRequire.cache[hotMarkerFile]) {
+                    delete safeRequire.cache[hotMarkerFile];
+                }
+            }
+            catch {
+                // ignore if not resolvable
+            }
+            // Reset our in-process caches
+            this.sectionProcessingErrors = {};
+            this.sectionFetchingErrors = {};
+            this.errorCount = 0;
+            this.allSectionsPromise = null;
+            this.allSectionsLoaded = false;
+            log('Invalidated section cache due to change in', relPath);
+            // Bump the hot marker to trigger Next.js Fast Refresh
+            this.bumpHotMarker();
+        };
+        watcher
+            .on('add', (path) => {
+            log('Section file added:', path);
+            invalidateForRelPath(path);
+        })
+            .on('change', (path) => {
+            log('Section file changed:', path);
+            invalidateForRelPath(path);
+        })
+            .on('unlink', (path) => {
+            log('Section file removed:', path);
+            invalidateForRelPath(path);
+        });
+    }
+    static init() {
+        if (this.isProd) {
+            // Preload all sections at startup in production
+            void this.loadAllSections();
+        }
+    }
+    /**
+     * Run initialization once when the module is loaded
+     */
+    static {
+        this.init();
+    }
+}

package/dist/core/fields/document.d.ts

@@ -54,7 +54,6 @@ export declare class DocumentField extends FileField<'document', Config> {
     private _buffer;
     private _folder;
     private _allowedExtensions;
-    readonly uploadsFolder: string;
     constructor(config: BaseFieldConfig<Config>, file?: File);
     exportForClient(): {
         maxFileSize: {

package/dist/core/fields/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/core/fields/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAQ1C,QAAA,MAAM,YAAY;IACd;;;;;;;OAOG;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;kBAEL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,aAAc,SAAQ,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5D,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAkB;IAC/D,QAAQ,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE,CAAA;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAA;IAE7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE,CAAqE;IAE1G;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,kBAAkB,CAAU;IAEpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAmC;gBAErD,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI;IAqDxC,eAAe;;kBAtED,MAAM;kBAAQ,IAAI,GAAG,IAAI;;;;;;;;;;;;;IA+EjD,iBAAiB,CAAC,EACpB,WAAW,EACX,MAAM,EACN,aAAiB,GACpB,EAAE;QACC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAClC,GAAG,OAAO,CAAC,UAAU,CAAC;IAevB;;OAEG;IACG,WAAW;IAiCK,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAezD;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIX,WAAW,CAAC,KAAK,EAAE,MAAM;IAIvB,QAAQ,CAAC,KAAK,EAAE,GAAG;IAQnB,OAAO,CAAC,IAAI,EAAE,IAAI;IAK3B,aAAa;IAab;;OAEG;IACG,oBAAoB;CAoD7B;AAED,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAEpF,QAAA,MAAM,aAAa;IArRf;;;;;;;OAOG;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;kBA0QL,CAAA;AAEF,QAAA,MAAM,yBAAyB;;;IA1R3B;;;;;;;OAOG;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;kBAgRL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,mBAAmB,CAmBvF"}
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/core/fields/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAQ1C,QAAA,MAAM,YAAY;IACd;;;;;;;OAOG;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;kBAEL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,aAAc,SAAQ,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5D,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAkB;IAC/D,QAAQ,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE,CAAA;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAA;IAE7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE,CAAqE;IAE1G;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,kBAAkB,CAAU;gBAExB,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI;IAqDxC,eAAe;;kBApED,MAAM;kBAAQ,IAAI,GAAG,IAAI;;;;;;;;;;;;;IA6EjD,iBAAiB,CAAC,EACpB,WAAW,EACX,MAAM,EACN,aAAiB,GACpB,EAAE;QACC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAClC,GAAG,OAAO,CAAC,UAAU,CAAC;IAevB;;OAEG;IACG,WAAW;IA+BK,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBzD;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIX,WAAW,CAAC,KAAK,EAAE,MAAM;IAIvB,QAAQ,CAAC,KAAK,EAAE,GAAG;IAQnB,OAAO,CAAC,IAAI,EAAE,IAAI;IAK3B,aAAa;IAab;;OAEG;IACG,oBAAoB;CAoD7B;AAED,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAEpF,QAAA,MAAM,aAAa;IAlRf;;;;;;;OAOG;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;kBAuQL,CAAA;AAEF,QAAA,MAAM,yBAAyB;;;IAvR3B;;;;;;;OAOG;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;kBA6QL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,mBAAmB,CAmBvF"}

package/dist/core/fields/document.js

@@ -42,7 +42,6 @@ export class DocumentField extends FileField {
     _buffer;
     _folder;
     _allowedExtensions;
-    uploadsFolder = getCMSConfig().media.upload.path;
     constructor(config, file) {
         super(config, 'document');
         if (file) {
@@ -127,14 +126,15 @@ export class DocumentField extends FileField {
             /**
              * If .documents, and 'sectionName' folders don't exist, create them
              */
-            const documentsFolder = path.join(this.uploadsFolder, '.documents', this._folder);
+            const uploadsFolder = (await getCMSConfig()).media.upload.path;
+            const documentsFolder = path.join(uploadsFolder, '.documents', this._folder);
             if (!fs.existsSync(documentsFolder)) {
                 fs.mkdirSync(documentsFolder, { recursive: true });
             }
             /**
              * Write the file to disk
              */
-            await fs.promises.writeFile(path.join(this.uploadsFolder, '.documents', this._folder, this.value), this._buffer);
+            await fs.promises.writeFile(path.join(uploadsFolder, '.documents', this._folder, this.value), this._buffer);
         }
         catch (error) {
             throw new Error(`${this.label}: Error writing file to disk ${error.message}`);
@@ -153,7 +153,8 @@ export class DocumentField extends FileField {
             throw new Error(`${this.label}: Folder is not set. Make sure to set the folder before writing the file to disk`);
         }
         try {
-            const pathToFile = path.join(this.uploadsFolder, '.documents', this._folder, this.value);
+            const uploadsFolder = (await getCMSConfig()).media.upload.path;
+            const pathToFile = path.join(uploadsFolder, '.documents', this._folder, this.value);
             await fs.promises.unlink(pathToFile);
         }
         catch (error) {

package/dist/core/fields/photo.d.ts

@@ -81,14 +81,10 @@ export declare class PhotoField extends FileField<'photo', Config> {
     };
     readonly mimeType: string[];
     readonly extensions: string[];
-    readonly thumbnail: {
-        width: number;
-        height: number;
-        crop: boolean;
-        quality?: number;
-    };
+    private _thumbnail;
+    /** Thumbnail config passed via field options (may be undefined if using CMS defaults) */
+    private _thumbnailConfig;
     readonly removeExtension: boolean;
-    readonly uploadsFolder: string;
     /**
      * _file is the file object if it's present
      * Whereas the value is the path to the file
@@ -98,6 +94,13 @@ export declare class PhotoField extends FileField<'photo', Config> {
     private _folder;
     private _allowedExtensions;
     constructor(config: BaseFieldConfig<Config>, file?: File);
+    /**
+     * Get the thumbnail configuration.
+     * Uses user-provided config if available, otherwise fetches from CMS config.
+     * Note: getCMSConfig() handles caching with version checking internally.
+     */
+    private getThumbnail;
+    build(): Promise<void>;
     exportForClient(): {
         thumbnail: {
             width: number;

package/dist/core/fields/photo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"photo.d.ts","sourceRoot":"","sources":["../../../src/core/fields/photo.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"photo.d.ts","sourceRoot":"","sources":["../../../src/core/fields/photo.ts"],"names":[],"mappings":"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"}