nextjs-cms 0.5.56 → 0.5.58

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

@@ -0,0 +1,509 @@
+import { glob } from 'glob';
+import { cloneDeep } from 'lodash-es';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import { eq } from 'drizzle-orm';
+import chokidar from 'chokidar';
+import fs, { existsSync, mkdirSync, statSync } from 'fs';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { db } from '../../db/client.js';
+import { AdminPrivilegesTable } from '../../db/schema.js';
+import { getCMSConfig } from '../config/index.js';
+import crypto from 'crypto';
+const cmsConfig = await getCMSConfig();
+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);
+/**
+ * Register esbuild-register only once per process.
+ * Node's require cache ensures each TS module is evaluated once.
+ */
+let tsLoaderRegistered = false;
+/**
+ * When we runtime-load TS (via esbuild-register) using CommonJS `require`, our TS sources may contain NodeNext-style
+ * specifiers like `./foo.js` that point at `./foo.ts` in the source tree. Node's CJS resolver won't find `foo.js`.
+ *
+ * In normal builds this is fine because `dist/foo.js` exists, but in dev/tests we load from `src/`.
+ * This helper patches Node's CJS resolver to fall back from `*.js` → `*.ts` for relative imports.
+ */
+const withPatchedCjsResolveJsToTs = (fn) => {
+    const NodeModule = safeRequire('module');
+    const originalResolve = NodeModule._resolveFilename;
+    NodeModule._resolveFilename = function (request, parent, isMain, options) {
+        try {
+            return originalResolve.call(this, request, parent, isMain, options);
+        }
+        catch (err) {
+            if (typeof request === 'string' && /^(\.{1,2}\/.*)\.js$/.test(request)) {
+                const tsRequest = request.replace(/\.js$/, '.ts');
+                try {
+                    return originalResolve.call(this, tsRequest, parent, isMain, options);
+                }
+                catch {
+                    // fall through to rethrow original error
+                }
+            }
+            throw err;
+        }
+    };
+    try {
+        return fn();
+    }
+    finally {
+        NodeModule._resolveFilename = originalResolve;
+    }
+};
+const loadEsbuildRegister = () => {
+    const id = 'esbuild-register/dist/node'; // avoid inline literal in require call
+    return safeRequire(id);
+};
+/**
+ * Runtime module import version token.
+ * Node caches ESM modules by URL. Adding `?v=` busts the cache when files change.
+ */
+let sectionImportVersion = 0;
+const getEsbuild = () => safeRequire('esbuild');
+const cacheRoot = resolve(process.cwd(), '.nextjs-cms', 'sections');
+if (!existsSync(cacheRoot))
+    mkdirSync(cacheRoot, { recursive: true });
+const hashKey = (s) => crypto.createHash('sha1').update(s).digest('hex');
+const ensureBundledSection = async (entryAbsPath) => {
+    const esbuild = getEsbuild();
+    // Make output stable per file + mtime (so edits re-bundle)
+    const st = statSync(entryAbsPath);
+    const key = hashKey(`${entryAbsPath}|${st.mtimeMs}`);
+    const outFile = join(cacheRoot, `${key}.mjs`);
+    if (existsSync(outFile))
+        return outFile;
+    // Bundle so extensionless imports work (esbuild resolves them)
+    await esbuild.build({
+        entryPoints: [entryAbsPath],
+        outfile: outFile,
+        bundle: true,
+        platform: 'node',
+        format: 'esm',
+        target: 'node18', // or node20, whatever you support
+        sourcemap: 'inline',
+        logLevel: 'silent',
+        // This is the magic for your UX:
+        resolveExtensions: ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'],
+        // Don’t bundle your library deps; keep them as runtime imports
+        packages: 'external',
+    });
+    return outFile;
+};
+const loadSectionModuleRuntime = async (absPath) => {
+    const isTs = absPath.endsWith('.ts') || absPath.endsWith('.cts') || absPath.endsWith('.mts');
+    // Keep tests using your old require-path + resolver patch (as before)
+    if (process.env.NODE_ENV === 'test') {
+        if (isTs && !tsLoaderRegistered) {
+            const { register } = loadEsbuildRegister();
+            register({ format: 'cjs', loader: 'ts' });
+            tsLoaderRegistered = true;
+        }
+        const mod = isTs ? withPatchedCjsResolveJsToTs(() => safeRequire(absPath)) : safeRequire(absPath);
+        return mod?.default;
+    }
+    // Dev/runtime: bundle then import the bundled output (Turbopack-safe)
+    const bundled = await ensureBundledSection(absPath);
+    const url = `${pathToFileURL(bundled).href}?v=${sectionImportVersion}`;
+    const mod = await import(/* turbopackIgnore: true */ url);
+    return mod?.default;
+};
+/**
+ * Log a message to the console if debug mode is enabled
+ * @param args - The arguments to log
+ * @returns void
+ */
+const log = (...args) => {
+    if (!cmsConfig.debug)
+        return;
+    console.log(chalk.black.bgGreen(`[${new Date().toISOString()}][next-cms-debug]`, ...args));
+};
+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 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 schema was updated.\n` +
+            ` * It is used to trigger a hot reload of the section schema 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() {
+        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();
+        }
+        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() {
+        if (!this.isDev || this.watcherStarted)
+            return;
+        this.watcherStarted = true;
+        const watcher = chokidar.watch('**/*.section.ts', {
+            cwd: cmsConfig.sections.path,
+            ignoreInitial: true,
+        });
+        log('Starting section watcher in dev mode...');
+        /**
+         * Invalidate section cache + bust runtime import cache.
+         * For Turbopack runtime import we increment sectionImportVersion which changes the URL (`?v=`).
+         * We still bump the hot marker to trigger Fast Refresh + react-query invalidation.
+         */
+        const invalidateForRelPath = (relPath) => {
+            // Bust ESM import cache (Node caches by URL)
+            sectionImportVersion++;
+            // 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);
+            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/factories/section-factory-with-jiti.d.ts

@@ -0,0 +1,113 @@
+import { HasItemsSection, SimpleSection, CategorySection } from '../sections/index.js';
+import type { CategorySectionConfig, HasItemsSectionConfig, SimpleSectionConfig } from '../sections/index.js';
+import type { SectionTypes } from '../types/index.js';
+type AnySectionConfig = HasItemsSectionConfig | SimpleSectionConfig | CategorySectionConfig;
+export declare class SectionFactory {
+    /**
+     * These are the fixed sections that can not be present in the sections folder.
+     */
+    static readonly fixedSections: string[];
+    private static readonly isDev;
+    private static readonly isProd;
+    private static sectionProcessingErrors;
+    private static sectionFetchingErrors;
+    private static errorCount;
+    /**
+     * 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.
+     */
+    private static allSectionsPromise;
+    private static allSectionsLoaded;
+    private static watcherStarted;
+    private static configVersion;
+    private static sectionWatcher;
+    private static ensureConfigFresh;
+    static bumpHotMarker(): void;
+    /**
+     * Get all sections
+     * @param type - The type of sections to get
+     * @returns The sections
+     */
+    static getSections(type?: SectionTypes | SectionTypes[]): Promise<AnySectionConfig[]>;
+    /**
+     * 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 getSectionsForAdmin({ type, admin, }: {
+        type?: SectionTypes | SectionTypes[];
+        admin: {
+            id: string;
+            requiredRole?: 'C' | 'U' | 'D';
+        };
+    }): Promise<{
+        simple: SimpleSectionConfig[];
+        has_items: HasItemsSectionConfig[];
+        category: CategorySectionConfig[];
+        fixed: string[];
+    }>;
+    /**
+     * Get a section
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @returns The section
+     */
+    static getSection({ name, type, }: {
+        name: string;
+        type?: SectionTypes | SectionTypes[];
+    }): Promise<AnySectionConfig | 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 getSectionForAdmin({ name, type, admin, }: {
+        name: string;
+        type?: SectionTypes | SectionTypes[];
+        admin: {
+            id: string;
+            requiredRole?: 'C' | 'U' | 'D';
+        };
+    }): Promise<AnySectionConfig | 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: {
+        build: () => HasItemsSection | SimpleSection | CategorySection;
+        [key: string]: any;
+    }): HasItemsSection | SimpleSection | CategorySection;
+    /**
+     * 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)
+     */
+    private static get;
+    /**
+     * 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).
+     */
+    private static loadAllSections;
+    private static startWatcher;
+    private static init;
+}
+export {};
+//# sourceMappingURL=section-factory-with-jiti.d.ts.map

package/dist/core/factories/section-factory-with-jiti.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"section-factory-with-jiti.d.ts","sourceRoot":"","sources":["../../../src/core/factories/section-factory-with-jiti.ts"],"names":[],"mappings":"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"}