nextjs-cms 0.0.1 → 0.5.1

package/dist/core/config/config-loader.d.ts

@@ -0,0 +1,92 @@
+import * as z from 'zod';
+declare const cmsConfigSchema: z.ZodObject<{
+    sectionsFolder: z.ZodOptional<z.ZodString>;
+    api: z.ZodOptional<z.ZodObject<{
+        baseUrl: z.ZodString;
+    }, z.core.$strip>>;
+    siteName: z.ZodOptional<z.ZodString>;
+    theme: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodObject<{
+        upload: z.ZodObject<{
+            uploadPath: z.ZodString;
+            keepFileExtension: z.ZodBoolean;
+        }, z.core.$strip>;
+        images: z.ZodOptional<z.ZodObject<{
+            thumbnail: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                crop: z.ZodBoolean;
+                quality: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            watermark: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    sections: z.ZodOptional<z.ZodObject<{
+        category: z.ZodObject<{
+            allowRecursiveDelete: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    db: z.ZodOptional<z.ZodObject<{
+        schemaNamingConvention: z.ZodOptional<z.ZodObject<{
+            tableCaseStyle: z.ZodOptional<z.ZodEnum<{
+                camelCase: "camelCase";
+                snakeCase: "snakeCase";
+                pascalCase: "pascalCase";
+            }>>;
+            columnCaseStyle: z.ZodOptional<z.ZodEnum<{
+                camelCase: "camelCase";
+                snakeCase: "snakeCase";
+                pascalCase: "pascalCase";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CMSConfig = z.infer<typeof cmsConfigSchema>;
+export interface ComputedCMSConfig {
+    sectionsFolder: string;
+    api: {
+        baseUrl: string;
+    };
+    siteName: string;
+    theme: string;
+    files: {
+        upload: {
+            uploadPath: string;
+            keepFileExtension: boolean;
+        };
+        images: {
+            thumbnail: {
+                width: number;
+                height: number;
+                crop: boolean;
+                quality: number;
+            };
+            watermark: boolean;
+        };
+    };
+    sections: {
+        category: {
+            allowRecursiveDelete: boolean;
+        };
+    };
+    db: {
+        schemaNamingConvention: {
+            tableCaseStyle: 'camelCase' | 'snakeCase' | 'pascalCase';
+            columnCaseStyle: 'camelCase' | 'snakeCase' | 'pascalCase';
+        };
+    };
+    debug: boolean;
+    strict: boolean;
+}
+/**
+ * Gets the CMS configuration, loading it lazily on first access.
+ * The configuration is cached after the first load for performance.
+ *
+ * @returns A readonly computed CMS configuration with all required fields
+ * @throws Error if the config file exists but is invalid
+ */
+export declare function getCMSConfig(): Readonly<ComputedCMSConfig>;
+export {};
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/core/config/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../../src/core/config/config-loader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmGnB,CAAA;AAGF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAGvD,MAAM,WAAW,iBAAiB;IAC9B,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,EAAE;QACD,OAAO,EAAE,MAAM,CAAA;KAClB,CAAA;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE;QACH,MAAM,EAAE;YACJ,UAAU,EAAE,MAAM,CAAA;YAClB,iBAAiB,EAAE,OAAO,CAAA;SAC7B,CAAA;QACD,MAAM,EAAE;YACJ,SAAS,EAAE;gBACP,KAAK,EAAE,MAAM,CAAA;gBACb,MAAM,EAAE,MAAM,CAAA;gBACd,IAAI,EAAE,OAAO,CAAA;gBACb,OAAO,EAAE,MAAM,CAAA;aAClB,CAAA;YACD,SAAS,EAAE,OAAO,CAAA;SACrB,CAAA;KACJ,CAAA;IACD,QAAQ,EAAE;QACN,QAAQ,EAAE;YACN,oBAAoB,EAAE,OAAO,CAAA;SAChC,CAAA;KACJ,CAAA;IACD,EAAE,EAAE;QACA,sBAAsB,EAAE;YACpB,cAAc,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;YACxD,eAAe,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;SAC5D,CAAA;KACJ,CAAA;IACD,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAClB;AAyHD;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,QAAQ,CAAC,iBAAiB,CAAC,CAW1D"}

package/dist/core/config/config-loader.js

@@ -0,0 +1,230 @@
+if (typeof window !== 'undefined') {
+    throw new Error('This module can only run on the server');
+}
+// import 'server-only'
+// import chalk from 'chalk'
+import * as z from 'zod';
+import { loadConfigModule } from './loader';
+// 1. Define config schema
+const cmsConfigSchema = z.object({
+    /**
+     * The folder where the sections are located
+     */
+    sectionsFolder: z.string().optional(),
+    api: z
+        .object({
+        /**
+         * The base URL of the cms
+         */
+        baseUrl: z.string(),
+    })
+        .optional(),
+    /**
+     * The name of the site
+     */
+    siteName: z.string().optional(),
+    theme: z.string().optional(),
+    /**
+     * Files configuration
+     */
+    files: z
+        .object({
+        /**
+         * Upload configuration
+         */
+        upload: z.object({
+            /**
+             * The path where the files are uploaded
+             */
+            uploadPath: z.string(),
+            /**
+             * Whether to keep the file extension
+             */
+            keepFileExtension: z.boolean(),
+        }),
+        /**
+         * Images configuration
+         */
+        images: z
+            .object({
+            /**
+             * Global images thumbnail configuration
+             */
+            thumbnail: z
+                .object({
+                width: z.number(),
+                height: z.number(),
+                crop: z.boolean(),
+                quality: z.number().optional(),
+            })
+                .optional(),
+            /**
+             * Global images watermark configuration
+             */
+            watermark: z.boolean().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    sections: z
+        .object({
+        category: z.object({
+            /**
+             * Whether to allow recursive deletion
+             */
+            allowRecursiveDelete: z.boolean(),
+        }),
+    })
+        .optional(),
+    /**
+     * Database configuration
+     */
+    db: z
+        .object({
+        schemaNamingConvention: z
+            .object({
+            /**
+             * The case style of the table name
+             */
+            tableCaseStyle: z.enum(['camelCase', 'snakeCase', 'pascalCase']).optional(),
+            /**
+             * The case style of the column name
+             */
+            columnCaseStyle: z.enum(['camelCase', 'snakeCase', 'pascalCase']).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    debug: z.boolean().optional(),
+    /**
+     * Whether to enable strict mode.
+     * @default false
+     */
+    strict: z.boolean().optional(),
+});
+// Merge utility function
+function mergeConfig(defaults, userConfig) {
+    return {
+        sectionsFolder: userConfig.sectionsFolder ?? defaults.sectionsFolder,
+        siteName: userConfig.siteName ?? defaults.siteName,
+        strict: userConfig.strict ?? defaults.strict,
+        api: {
+            baseUrl: userConfig.api?.baseUrl ?? defaults.api.baseUrl,
+        },
+        theme: userConfig.theme ?? defaults.theme,
+        files: {
+            upload: {
+                uploadPath: userConfig.files?.upload?.uploadPath ?? defaults.files.upload.uploadPath,
+                keepFileExtension: userConfig.files?.upload?.keepFileExtension ?? defaults.files.upload.keepFileExtension,
+            },
+            images: {
+                thumbnail: {
+                    width: userConfig.files?.images?.thumbnail?.width ?? defaults.files.images.thumbnail.width,
+                    height: userConfig.files?.images?.thumbnail?.height ?? defaults.files.images.thumbnail.height,
+                    crop: userConfig.files?.images?.thumbnail?.crop ?? defaults.files.images.thumbnail.crop,
+                    quality: userConfig.files?.images?.thumbnail?.quality ?? defaults.files.images.thumbnail.quality,
+                },
+                watermark: userConfig.files?.images?.watermark ?? defaults.files.images.watermark,
+            },
+        },
+        sections: {
+            category: {
+                allowRecursiveDelete: userConfig.sections?.category?.allowRecursiveDelete ??
+                    defaults.sections.category.allowRecursiveDelete,
+            },
+        },
+        db: {
+            schemaNamingConvention: {
+                tableCaseStyle: userConfig.db?.schemaNamingConvention?.tableCaseStyle ??
+                    defaults.db.schemaNamingConvention.tableCaseStyle,
+                columnCaseStyle: userConfig.db?.schemaNamingConvention?.columnCaseStyle ??
+                    defaults.db.schemaNamingConvention.columnCaseStyle,
+            },
+        },
+        debug: userConfig.debug ?? defaults.debug,
+    };
+}
+// Default configuration values
+const defaultConfig = {
+    sectionsFolder: 'sections',
+    siteName: 'LZ CMS Admin',
+    api: {
+        baseUrl: '/api',
+    },
+    theme: 'dark',
+    files: {
+        upload: {
+            uploadPath: './public/content',
+            keepFileExtension: true,
+        },
+        images: {
+            thumbnail: {
+                width: 200,
+                height: 200,
+                crop: false,
+                quality: 80,
+            },
+            watermark: false,
+        },
+    },
+    sections: {
+        category: {
+            allowRecursiveDelete: false,
+        },
+    },
+    db: {
+        schemaNamingConvention: {
+            tableCaseStyle: 'pascalCase',
+            columnCaseStyle: 'camelCase',
+        },
+    },
+    debug: false,
+    strict: false,
+};
+/*const error = (error: string, greyMsg = ''): string => {
+    return `${chalk.bgRed.bold(' Error ')} ${error} ${greyMsg ? chalk.grey(greyMsg) : ''}`.trim()
+}*/
+let cachedConfig;
+/**
+ * Loads and parses the user configuration module.
+ * This is called lazily when getCMSConfig() is first invoked.
+ *
+ * @returns The parsed user configuration object, or undefined if no config file exists
+ * @throws Error if the config file exists but cannot be loaded or parsed
+ */
+function loadUserConfig() {
+    try {
+        const mod = loadConfigModule();
+        const config = mod ? (mod.config ?? mod) : undefined;
+        if (!config) {
+            return undefined;
+        }
+        // Parse and validate the user config
+        return cmsConfigSchema.parse(config);
+    }
+    catch (error) {
+        // If config file doesn't exist, return undefined to use defaults
+        // Otherwise, re-throw the error as it's a real problem
+        if (error instanceof Error && error.message.includes('Config file not found')) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+/**
+ * Gets the CMS configuration, loading it lazily on first access.
+ * The configuration is cached after the first load for performance.
+ *
+ * @returns A readonly computed CMS configuration with all required fields
+ * @throws Error if the config file exists but is invalid
+ */
+export function getCMSConfig() {
+    if (cachedConfig === undefined) {
+        // Load user config lazily (only when this function is first called)
+        const userConfig = loadUserConfig();
+        // Merge user config with defaults
+        const mergedConfig = mergeConfig(defaultConfig, userConfig ?? {});
+        cachedConfig = mergedConfig;
+    }
+    return cachedConfig;
+}

package/dist/core/config/index.d.ts

@@ -0,0 +1,3 @@
+export { getCMSConfig } from './config-loader';
+export type { CMSConfig } from './config-loader';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/core/config/index.js

@@ -0,0 +1 @@
+export { getCMSConfig } from './config-loader';

package/dist/core/config/loader.d.ts

@@ -0,0 +1,2 @@
+export declare const loadConfigModule: () => unknown;
+//# sourceMappingURL=loader.d.ts.map

package/dist/core/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/core/config/loader.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,gBAAgB,QAAO,OAwCnC,CAAA"}

package/dist/core/config/loader.js

@@ -0,0 +1,42 @@
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+// Keep bundlers from statically analyzing these requires
+const safeRequire = (id) => {
+    const req = eval('require');
+    return req(id);
+};
+export const loadConfigModule = () => {
+    const cwd = process.cwd();
+    const candidates = [
+        'lz.config.js',
+        'lz.config.cjs',
+        'lz.config.mjs',
+        'lz.config.json',
+        'lz.config.ts',
+        'lz.config.cts',
+        'lz.config.mts',
+    ].map((f) => resolve(join(cwd, f)));
+    const found = candidates.find((p) => existsSync(p));
+    if (!found) {
+        throw new Error(`Config file not found. Searched: ${candidates.join(', ')}`);
+    }
+    const isTs = found.endsWith('.ts') || found.endsWith('.cts') || found.endsWith('.mts');
+    let unregister;
+    try {
+        if (isTs) {
+            try {
+                const { register } = safeRequire('esbuild-register/dist/node');
+                unregister = register({ format: 'cjs', loader: 'ts' }).unregister;
+            }
+            catch {
+                throw new Error(`Unable to load TypeScript config '${found}'. Install 'esbuild-register' in nextjs-cms/cms, or provide lz.config.js/json.`);
+            }
+        }
+        const mod = safeRequire(found);
+        unregister?.();
+        return mod.default ?? mod;
+    }
+    finally {
+        unregister?.();
+    }
+};

package/dist/core/db/index.d.ts

@@ -0,0 +1,2 @@
+export { MysqlTableChecker } from './table-checker';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/db/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/core/db/index.js

@@ -0,0 +1 @@
+export { MysqlTableChecker } from './table-checker';

package/dist/core/db/table-checker/DbTable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Base class for table information
+ */
+export declare abstract class DbTableChecker {
+}
+//# sourceMappingURL=DbTable.d.ts.map

package/dist/core/db/table-checker/DbTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DbTable.d.ts","sourceRoot":"","sources":["../../../../src/core/db/table-checker/DbTable.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,8BAAsB,cAAc;CAEnC"}

package/dist/core/db/table-checker/DbTable.js

@@ -0,0 +1,5 @@
+/**
+ * Base class for table information
+ */
+export class DbTableChecker {
+}

package/dist/core/db/table-checker/MysqlTable.d.ts

@@ -0,0 +1,34 @@
+import { DbTableChecker } from './DbTable';
+/**
+ * MySQL Table class
+ */
+export declare class MysqlTableChecker extends DbTableChecker {
+    static getColumns(tableName: string): Promise<string[]>;
+    static getExistingKeys(table: string): Promise<{
+        primaryKeys: string[];
+        uniqueKeys: {
+            name: string;
+            columns: string[];
+        }[];
+        indexKeys: {
+            name: string;
+            columns: string[];
+        }[];
+        foreignKeys: any;
+        fullTextKeys: {
+            name: string;
+            columns: string[];
+        }[];
+    } | undefined>;
+    static getExistingTableStructure(table: string): Promise<{
+        [key: string]: {
+            Field: string;
+            Type: string;
+            Null: string;
+            Key: string;
+            Default: string;
+            Extra: string;
+        };
+    } | null>;
+}
+//# sourceMappingURL=MysqlTable.d.ts.map

package/dist/core/db/table-checker/MysqlTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MysqlTable.d.ts","sourceRoot":"","sources":["../../../../src/core/db/table-checker/MysqlTable.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAG1C;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,cAAc;WACpC,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;WAkBhD,eAAe,CAAC,KAAK,EAAE,MAAM;;;kBAIR,MAAM;qBAAW,MAAM,EAAE;;;kBAC1B,MAAM;qBAAW,MAAM,EAAE;;;;kBACtB,MAAM;qBAAW,MAAM,EAAE;;;WA2DhD,yBAAyB,CAAC,KAAK,EAAE,MAAM;;mBAU7B,MAAM;kBACP,MAAM;kBACN,MAAM;iBACP,MAAM;qBACF,MAAM;mBACR,MAAM;;;CAahC"}

package/dist/core/db/table-checker/MysqlTable.js

@@ -0,0 +1,102 @@
+import { db } from '../../../db/client';
+import { sql } from 'drizzle-orm';
+import { DbTableChecker } from './DbTable';
+import chalk from 'chalk';
+/**
+ * MySQL Table class
+ */
+export class MysqlTableChecker extends DbTableChecker {
+    static async getColumns(tableName) {
+        const statement = sql `
+       SELECT COLUMN_NAME 
+      FROM information_schema.COLUMNS c
+      inner join information_schema.TABLES t ON t.TABLE_NAME = c.TABLE_NAME
+      WHERE t.TABLE_NAME = ${tableName}`;
+        const _cols = [];
+        const _res = await db.execute(statement);
+        // @ts-ignore
+        const _rows = _res[0];
+        _rows.map((row) => {
+            _cols.push(row.COLUMN_NAME);
+        });
+        return _cols;
+    }
+    static async getExistingKeys(table) {
+        try {
+            const [keys] = await db.execute(sql `SHOW KEYS FROM \`${sql.raw(table)}\``);
+            const primaryKeys = [];
+            const uniqueKeys = [];
+            const indexKeys = [];
+            const fullTextKeys = [];
+            const _uniqueKeyMap = {};
+            const _indexKeyMap = {};
+            const _fullTextKeyMap = {};
+            for (const key of keys) {
+                if (key.Key_name === 'PRIMARY') {
+                    primaryKeys.push(key.Column_name);
+                }
+                else if (key.Non_unique === 0) {
+                    if (!_uniqueKeyMap[key.Key_name]) {
+                        _uniqueKeyMap[key.Key_name] = [];
+                    }
+                    _uniqueKeyMap[key.Key_name].push(key.Column_name);
+                }
+                else if (key.Index_type === 'FULLTEXT') {
+                    if (!_fullTextKeyMap[key.Key_name]) {
+                        _fullTextKeyMap[key.Key_name] = [];
+                    }
+                    _fullTextKeyMap[key.Key_name].push(key.Column_name);
+                }
+                else if (key.Non_unique === 1) {
+                    if (!_indexKeyMap[key.Key_name]) {
+                        _indexKeyMap[key.Key_name] = [];
+                    }
+                    _indexKeyMap[key.Key_name].push(key.Column_name);
+                }
+            }
+            for (const key in _uniqueKeyMap) {
+                if (_uniqueKeyMap[key])
+                    uniqueKeys.push({ name: key, columns: _uniqueKeyMap[key] });
+            }
+            for (const key in _indexKeyMap) {
+                if (_indexKeyMap[key])
+                    indexKeys.push({ name: key, columns: _indexKeyMap[key] });
+            }
+            for (const key in _fullTextKeyMap) {
+                if (_fullTextKeyMap[key])
+                    fullTextKeys.push({ name: key, columns: _fullTextKeyMap[key] });
+            }
+            // Foreign keys should be retrieved from information_schema
+            const [foreignKeys] = await db.execute(sql `
+            SELECT COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+            FROM information_schema.KEY_COLUMN_USAGE
+            WHERE TABLE_NAME = ${table} AND CONSTRAINT_NAME != 'PRIMARY' AND REFERENCED_TABLE_NAME IS NOT NULL;
+        `);
+            return { primaryKeys, uniqueKeys, indexKeys, foreignKeys, fullTextKeys };
+        }
+        catch (error) {
+            if (error.code === 'ER_NO_SUCH_TABLE') {
+                return undefined;
+            }
+            else {
+                console.error(chalk.red(`  - Error retrieving keys for table ${table}:`, error));
+            }
+        }
+    }
+    static async getExistingTableStructure(table) {
+        try {
+            /**
+             * Get the columns from the table except the auto-generated `created_at`, `updated_at`, `created_by`, and `updated_by` fields
+             */
+            const [rows] = await db.execute(sql `SHOW COLUMNS FROM \`${sql.raw(table)}\` WHERE Field NOT IN ('created_at', 'updated_at', 'created_by', 'updated_by')`);
+            const tableStructure = {};
+            for (const row of rows) {
+                tableStructure[row.Field] = row;
+            }
+            return tableStructure;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+}

package/dist/core/db/table-checker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './MysqlTable';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/db/table-checker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/db/table-checker/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA"}

package/dist/core/db/table-checker/index.js

@@ -0,0 +1 @@
+export * from './MysqlTable';