nextjs-cms-kit 0.5.1

package/dist/lib/update-sections.js

@@ -0,0 +1,898 @@
+// import '@/envConfig'
+import { db } from 'nextjs-cms/db/client';
+import { LZTablesTable } from 'nextjs-cms/db/schema';
+import { eq, sql } from 'drizzle-orm';
+import fs from 'fs';
+import { SectionFactory } from 'nextjs-cms/core/factories';
+import { CheckboxField, ColorField, DateField, MapField, NumberField, PasswordField, RichTextField, SelectField, SelectMultipleField, TagsField, TextAreaField, TextField, textAreaField, textField, } from 'nextjs-cms/core/fields';
+import { is } from 'nextjs-cms/core/helpers';
+import { FileField } from 'nextjs-cms/core/fields';
+import chalk from 'chalk';
+import { intro, select, spinner, log } from '@clack/prompts';
+import { MysqlTableChecker } from 'nextjs-cms/core/db';
+import { generateDrizzleSchema } from './schema-generator';
+import { addTableKeys } from './add-table-keys';
+function generateFieldSQL(input) {
+    let fieldSQL = `\`${input.name}\` `;
+    /**
+     * Check the field type and generate the SQL accordingly
+     */
+    switch (true) {
+        case is(input, TextField):
+            fieldSQL += `VARCHAR(${input.maxLength ?? 255}) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`;
+            break;
+        case is(input, TextAreaField) || is(input, RichTextField):
+            fieldSQL += 'LONGTEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+        case is(input, SelectMultipleField):
+            fieldSQL += 'VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+        case is(input, SelectField):
+            if (input.optionsType === 'static' && input.options) {
+                fieldSQL += `ENUM(${input.options.map((option) => `'${option.value}'`).join(', ')}) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`;
+            }
+            else {
+                fieldSQL += 'VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            }
+            break;
+        case is(input, CheckboxField):
+            fieldSQL += 'BOOLEAN';
+            break;
+        case is(input, ColorField):
+            fieldSQL += 'CHAR(7)'; // #RRGGBB
+            break;
+        case is(input, DateField):
+            switch (input.format) {
+                case 'date':
+                    fieldSQL += 'DATE';
+                    break;
+                case 'datetime':
+                    fieldSQL += 'DATETIME';
+                    break;
+                case 'timestamp':
+                    fieldSQL += 'TIMESTAMP';
+                    break;
+                default:
+                    fieldSQL += 'DATETIME';
+                    break;
+            }
+            break;
+        case is(input, NumberField): {
+            // Default format: 'int' if not specified
+            const format = input.format;
+            // FLOAT / DOUBLE
+            if (format === 'float' || format === 'double') {
+                fieldSQL += format === 'float' ? 'FLOAT' : 'DOUBLE';
+                if (input.minValue !== undefined && input.minValue >= 0) {
+                    fieldSQL += ' UNSIGNED';
+                }
+                break;
+            }
+            // ---------- INTEGER TYPES ----------
+            const unsigned = input.minValue !== undefined && input.minValue >= 0;
+            // Decide if we have any bounds we can use to shrink the integer type
+            const hasBounds = input.minValue !== undefined || input.maxValue !== undefined || input.maxLength !== undefined;
+            // From maxLength, approximate numeric bounds if explicit min/max not provided
+            const pow10 = (d) => Math.pow(10, d);
+            const approxFromDigits = (digits) => {
+                if (digits === undefined)
+                    return {};
+                const max = pow10(digits) - 1;
+                // if unsigned, min will be clamped to 0 below
+                const min = -max;
+                return { min, max };
+            };
+            const approx = approxFromDigits(input.maxLength);
+            let neededMin = input.minValue ?? approx.min;
+            const neededMax = input.maxValue ?? approx.max;
+            if (unsigned)
+                neededMin = neededMin === undefined ? 0 : Math.max(0, neededMin);
+            const ranges = unsigned
+                ? [
+                    { type: 'TINYINT', min: 0, max: 255 },
+                    { type: 'SMALLINT', min: 0, max: 65_535 },
+                    { type: 'MEDIUMINT', min: 0, max: 16_777_215 },
+                    { type: 'INT', min: 0, max: 4_294_967_295 },
+                    // BIGINT max clipped to safe JS number for comparison purposes
+                    { type: 'BIGINT', min: 0, max: Number.MAX_SAFE_INTEGER },
+                ]
+                : [
+                    { type: 'TINYINT', min: -128, max: 127 },
+                    { type: 'SMALLINT', min: -32_768, max: 32_767 },
+                    { type: 'MEDIUMINT', min: -8_388_608, max: 8_388_607 },
+                    { type: 'INT', min: -2_147_483_648, max: 2_147_483_647 },
+                    { type: 'BIGINT', min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+                ];
+            const fits = (r) => {
+                const okMin = neededMin === undefined || neededMin >= r.min;
+                const okMax = neededMax === undefined || neededMax <= r.max;
+                return okMin && okMax;
+            };
+            // Choose type:
+            // - If no bounds at all, default to INT (common + avoids accidental TINYINT)
+            // - If auto-increment and still no bounds, keep INT
+            // - Otherwise, pick the smallest that fits
+            let chosen = 'INT';
+            if (hasBounds) {
+                chosen = ranges.find(fits)?.type ?? 'INT';
+                // If auto-increment, don't go smaller than INT by default (optional safety)
+                if (input.hasAutoIncrement &&
+                    (chosen === 'TINYINT' || chosen === 'SMALLINT' || chosen === 'MEDIUMINT')) {
+                    chosen = 'INT';
+                }
+            }
+            fieldSQL += chosen;
+            if (unsigned)
+                fieldSQL += ' UNSIGNED';
+            // Display width:
+            // - If user specified maxLength, honor it for any integer type
+            // - Else, if chosen is INT, default to (11) as requested
+            const width = input.maxLength ?? (chosen === 'INT' ? 11 : undefined);
+            if (width !== undefined) {
+                fieldSQL += `(${width})`;
+            }
+            // AUTO_INCREMENT only for integer types
+            if (input.hasAutoIncrement) {
+                fieldSQL += ' AUTO_INCREMENT';
+            }
+            break;
+        }
+        case is(input, MapField):
+            fieldSQL += 'VARCHAR(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+        case is(input, FileField):
+            fieldSQL += 'VARCHAR(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+        case is(input, PasswordField):
+            fieldSQL += 'VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+        case is(input, TagsField):
+            fieldSQL += 'VARCHAR(50)  CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+        default:
+            fieldSQL += 'VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
+            break;
+    }
+    if (input.required && !input.isConditional()) {
+        fieldSQL += ' NOT NULL';
+    }
+    else if (!input.defaultValue) {
+        fieldSQL += ' DEFAULT NULL';
+    }
+    if (input.defaultValue !== null && input.defaultValue !== undefined) {
+        fieldSQL += ` DEFAULT '${input.defaultValue}'`;
+    }
+    return fieldSQL;
+}
+async function createTable(table, options) {
+    /**
+     * Generate the CREATE TABLE SQL
+     */
+    let createTableSQL = `CREATE TABLE \`${table.name}\` (`;
+    /**
+     * Loop through the fields and generate the SQL for each field
+     */
+    for (const input of table.fields) {
+        if (input.destinationDb)
+            continue;
+        let fieldSQL = generateFieldSQL(input);
+        /**
+         * Check if the field is a primary key
+         */
+        if (input.name === table.identifier?.name) {
+            fieldSQL += ' UNIQUE';
+        }
+        createTableSQL += `${fieldSQL}, `;
+    }
+    /**
+     * Now, let's add the `created_at`, `updated_at`, `created_by`, and `updated_by` fields
+     */
+    if (options) {
+        if (options.createdAt !== false) {
+            createTableSQL += '`created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP, ';
+        }
+        if (options.updatedAt !== false) {
+            createTableSQL += '`updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, ';
+        }
+        if (options.createdBy !== false) {
+            createTableSQL += '`created_by` VARCHAR(50) NOT NULL, '; // Should reference the admin ID?
+        }
+        if (options.updatedBy !== false) {
+            createTableSQL += '`updated_by` VARCHAR(50), '; // Should reference the admin ID?
+        }
+    }
+    /**
+     * Add the primary key
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!(table.primaryKey && table.primaryKey.length > 0)) {
+        /**
+         * Log a warning if there's no primary key
+         */
+        console.warn(chalk.yellow(`  - Warning: Table \`${table.name}\` has no primary key!`));
+    }
+    else {
+        // addTableKeys function will handle the primary key
+        /*createTableSQL += 'PRIMARY KEY ('
+        for (const key of table.primaryKey) {
+            createTableSQL += `\`${key.name}\`, `
+        }
+        createTableSQL = createTableSQL.slice(0, -2) + '), '*/
+    }
+    /**
+     * Remove the last comma and space, and then close the CREATE TABLE statement
+     */
+    createTableSQL = createTableSQL.slice(0, -2) + ') ENGINE=InnoDB;';
+    /**
+     * Try to create the table
+     */
+    try {
+        /**
+         * Execute the CREATE TABLE SQL
+         */
+        await db.execute(sql `${sql.raw(createTableSQL)}`);
+        /**
+         * Insert the table name into the `__lz_tables` table
+         */
+        await db
+            .insert(LZTablesTable)
+            .values({
+            tableName: table.name,
+            sectionName: table.sectionName,
+        })
+            .catch((error) => {
+            console.error('Error inserting into __lz_tables table:', error);
+        });
+    }
+    catch (error) {
+        console.log(chalk.red(`  - Error creating table \`${table.name}\`:`, error));
+    }
+    /**
+     * Get the existing keys for the table
+     */
+    const existingKeys = await MysqlTableChecker.getExistingKeys(table.name);
+    /**
+     * Add the keys to the table
+     */
+    const keyErrors = await addTableKeys(table, existingKeys);
+    console.log(chalk.italic.hex(`${keyErrors > 0 ? `#FFA500` : `#fafafa`}`)(`  - Table \`${table.name}\` created successfully ${keyErrors > 0 ? `with ${keyErrors} error(s).` : ''}`));
+}
+async function renameTable(oldName, newName) {
+    /**
+     * Execute ALTER TABLE statement to rename the table
+     */
+    try {
+        await db.execute(sql `ALTER TABLE \`${sql.raw(oldName)}\` RENAME \`${sql.raw(newName)}\``);
+        /**
+         * Update the table name in the `__lz_tables` table
+         */
+        await db
+            .update(LZTablesTable)
+            .set({
+            tableName: newName,
+        })
+            .where(eq(LZTablesTable.tableName, oldName))
+            .catch((error) => {
+            console.error('Error updating __lz_tables table:', error);
+        });
+        console.log(`Table \`${oldName}\` renamed to \`${newName}\` successfully.`);
+    }
+    catch (error) {
+        console.error(`Error renaming table \`${oldName}\` to \`${newName}\`:`, error);
+    }
+}
+async function updateTable(table, s) {
+    console.log();
+    console.log(chalk.blueBright(`Updating table '${table.name}' for section '${table.sectionName}'`));
+    s.start();
+    /**
+     * Get the existing keys for the table
+     */
+    const existingKeys = await MysqlTableChecker.getExistingKeys(table.name);
+    /**
+     * Get the existing table structure (columns)
+     */
+    const existingFieldsData = await MysqlTableChecker.getExistingTableStructure(table.name);
+    let sqlErrors = 0;
+    const alterTableSQLs = [];
+    /**
+     * Filter out the fields that already exist in the table
+     */
+    const existingFields = existingFieldsData ? Object.keys(existingFieldsData) : [];
+    const fieldsToAdd = table.fields.filter((field) => !existingFields.some((existingField) => existingField === field.name));
+    /**
+     * Let's find out fields that need to be updated.
+     * If a field exists in both the desired fields and the existing fields, we should mark it for update.
+     * TODO: Actually, we should check if the field needs to be updated, and only update if necessary. (INFORMATION_SCHEMA will help)
+     */
+    const fieldsToUpdate = table.fields.filter((field) => existingFields.some((existingField) => existingField === field.name));
+    /**
+     * Let's find out fields to remove as well.
+     * If a field exists in the table but not in the desired fields,
+     * or if it has a destinationDb, TODO: Add the values to the destination table? (CRITICAL! Loss of data if not done)
+     * we should mark it for removal.
+     */
+    let fieldsToRemove = existingFields.filter((existingField) => !table.fields.some((field) => field.name === existingField) ||
+        table.fields.some((field) => field.destinationDb && field.name === existingField));
+    /**
+     * Check if there are fields to update
+     */
+    if (fieldsToUpdate.length > 0) {
+        /**
+         * Loop through the tables to update
+         */
+        for (const field of fieldsToUpdate) {
+            // TODO: We should also check if the field type has changed,
+            //  and if so, notify the user that the field type will be updated,
+            //  and data may be lost! (e.g. changing a field from VARCHAR to INT)
+            if (field.destinationDb)
+                continue;
+            let fieldSQL = generateFieldSQL(field);
+            /**
+             * Check if the field is a primary key
+             */
+            if (field.name === table.identifier?.name) {
+                fieldSQL += ' FIRST';
+            }
+            /**
+             * Add the SQL to modify the field
+             */
+            alterTableSQLs.push({
+                field: field.name,
+                table: table.name,
+                action: 'modify',
+                sql: `MODIFY COLUMN ${fieldSQL}`,
+            });
+        }
+    }
+    /**
+     * Check if there are fields to add
+     */
+    if (fieldsToAdd.length > 0) {
+        /**
+         * Loop through the fields to add
+         */
+        for (const field of fieldsToAdd) {
+            if (field.destinationDb)
+                continue;
+            let fieldSQL = generateFieldSQL(field);
+            /**
+             * Check if the field is an identifier
+             */
+            if (field.name === table.identifier?.name) {
+                fieldSQL += ' UNIQUE FIRST';
+            }
+            /**
+             * Check if there are fields to remove
+             * If there are, ask the user if they want to add the new field or rename a to-be-removed field
+             */
+            if (fieldsToRemove.length > 0) {
+                s.stop();
+                const opType = await select({
+                    message: `Is field '${field.name}' of table '${table.name}' a new field?`,
+                    options: [
+                        { value: 'new', label: 'Create new field' },
+                        { value: 'rename', label: 'Rename existing field' },
+                    ],
+                });
+                s.start();
+                switch (opType) {
+                    case 'new':
+                        /**
+                         * Field doesn't exist.
+                         * Add the field to the table
+                         */
+                        alterTableSQLs.push({
+                            field: field.name,
+                            table: table.name,
+                            action: 'add',
+                            sql: `ADD COLUMN ${fieldSQL}`,
+                        });
+                        break;
+                    case 'rename': {
+                        s.stop();
+                        const oldField = await select({
+                            message: `Select the field to rename to '${field.name}'`,
+                            options: fieldsToRemove.map((field) => {
+                                return { value: field, label: field };
+                            }),
+                        });
+                        s.start();
+                        if (oldField && typeof oldField === 'string') {
+                            console.log(`Renaming field '${oldField}' to '${field.name}'`);
+                            /**
+                             * Rename the field
+                             */
+                            alterTableSQLs.push({
+                                field: field.name,
+                                table: table.name,
+                                action: 'rename',
+                                sql: `RENAME COLUMN \`${oldField}\` TO ${field.name}`,
+                            });
+                            /**
+                             * Remove the field from the fieldsToRemove array
+                             */
+                            fieldsToRemove = fieldsToRemove.filter((field) => {
+                                return field !== oldField;
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+            else {
+                /**
+                 * Field doesn't exist.
+                 * Add the field to the table
+                 */
+                alterTableSQLs.push({
+                    field: field.name,
+                    table: table.name,
+                    action: 'add',
+                    sql: `ADD COLUMN ${fieldSQL}`,
+                });
+            }
+        }
+    }
+    /**
+     * Finally, check if there are fields to remove
+     */
+    if (fieldsToRemove.length > 0) {
+        /**
+         * Loop through the fields to remove
+         */
+        s.stop('Found ' + fieldsToRemove.length + ' field(s) to remove:');
+        for (const field of fieldsToRemove) {
+            const shouldRemove = await select({
+                message: `You are about to remove field '${field}' of table '${table.name}'. Remove it?`,
+                options: [
+                    { value: 'no', label: 'No' },
+                    { value: 'yes', label: 'Yes' },
+                ],
+                initialValue: 'no',
+            });
+            if (shouldRemove === 'yes') {
+                log.info(chalk.red(`Removing field '${field}'`));
+                alterTableSQLs.push({
+                    field: field,
+                    table: table.name,
+                    action: 'remove',
+                    sql: `DROP COLUMN \`${field}\``,
+                });
+            }
+            else {
+                log.info(chalk.yellow(`- Field ${chalk.underline.italic(field)} not removed.`));
+            }
+            s.start();
+        }
+    }
+    /**
+     * Execute ALTER TABLE statements
+     */
+    for (const alterSQL of alterTableSQLs) {
+        try {
+            await db.execute(sql `ALTER TABLE \`${sql.raw(table.name)}\` ${sql.raw(alterSQL.sql)}`);
+            switch (alterSQL.action) {
+                case 'add':
+                    console.log(chalk.gray(`  - Field ${chalk.underline.italic(alterSQL.field)} Added to \`${table.name}\`.`));
+                    break;
+                case 'modify':
+                    // Activate this when we only update the fields that need to be updated
+                    // console.log(chalk.gray(`  - ${alterSQL.field}: Modified in \`${table.name}\`.`))
+                    break;
+                case 'remove':
+                    console.log(chalk.gray(`  - Field ${chalk.underline.italic(alterSQL.field)} Removed from \`${table.name}\`.`));
+                    break;
+            }
+        }
+        catch (error) {
+            sqlErrors++;
+            console.error(chalk.red(`  - ${alterSQL.field}: Error modifying \`${table.name}\`.\`${alterSQL.field}\`:`, error));
+        }
+    }
+    /**
+     * Add the keys to the table
+     */
+    const keyErrors = await addTableKeys(table, existingKeys);
+    sqlErrors += keyErrors;
+    s.stop(chalk.italic.hex(`${sqlErrors > 0 ? `#FFA500` : `#fafafa`}`)(`- Table \`${table.name}\` modified successfully ${sqlErrors > 0 ? `with ${sqlErrors} error(s).` : ''}`));
+}
+const main = async (s) => {
+    /**
+     * Remove the existing schema file
+     */
+    console.log(chalk.white(`Removing existing schema file...`));
+    s.start();
+    const schemaFilePath = './dynamic-schemas/schema.ts';
+    try {
+        if (fs.existsSync(schemaFilePath)) {
+            fs.unlinkSync(schemaFilePath);
+        }
+    }
+    catch (error) {
+        console.error('Error removing schema file:', error);
+    }
+    s.stop();
+    console.log(chalk.white(`Generating Drizzle schema...`));
+    s.start();
+    const drizzleTableSchemas = [];
+    const drizzleColumnTypes = ['mysqlTable'];
+    let sections = [];
+    const desiredTables = [];
+    let existingTables = [];
+    sections = await SectionFactory.getSections();
+    console.log(`Found ${sections.length} section(s) to insert: `);
+    console.log(chalk.gray(sections.map((s) => s.name).join(', ')));
+    /**
+     * Let's see if the table `__lz_tables` exists in the database.
+     * If it doesn't, we'll create it.
+     * It has two fields: `name` and `created_at`.
+     */
+    await db.execute(sql ` CREATE TABLE IF NOT EXISTS __lz_tables ( name VARCHAR(100) NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ) `);
+    /**
+     * Get the existing tables from the database
+     */
+    existingTables = await db
+        .select({
+        name: LZTablesTable.tableName,
+    })
+        .from(LZTablesTable);
+    /**
+     * Insert the sections into the database
+     */
+    for (const _s of sections) {
+        const s = _s.build();
+        s.buildFields();
+        /**
+         * Generate the Drizzle schema for the table
+         */
+        const drizzleSchema = generateDrizzleSchema({
+            name: s.db.table,
+            fields: s.fieldConfigs,
+            identifier: s.db.identifier,
+        });
+        drizzleTableSchemas.push(drizzleSchema.schema);
+        drizzleSchema.columnTypes.forEach((type) => {
+            if (!drizzleColumnTypes.includes(type)) {
+                drizzleColumnTypes.push(type);
+            }
+        });
+        desiredTables.push({
+            name: s.db.table,
+            fields: s.fields,
+            sectionName: s.name,
+            sectionType: s.type,
+            identifier: s.db.identifier,
+            primaryKey: s.db.primaryKey,
+            fulltext: s.db.fulltext,
+            unique: s.db.unique,
+            index: s.db.index,
+        });
+        /**
+         * Check for `destinationDb`
+         */
+        for (const field of s.fields) {
+            /**
+             * TODO: We should also check for input.db in select fields, and add the table to the desiredTables array!
+             */
+            if (field.destinationDb) {
+                console.log('Destination DB found for input:', field.name, 'with table:', field.destinationDb.table);
+                /**
+                 * TODO: We should get the type of the identifier and the Select fields to match the types
+                 */
+                const referenceIdFieldConfig = textField({
+                    name: field.destinationDb.itemIdentifier,
+                    label: 'Reference Id',
+                    required: true,
+                    order: 0,
+                });
+                const selectIdFieldConfig = textField({
+                    name: field.destinationDb.selectIdentifier,
+                    label: 'Select Id',
+                    required: true,
+                    order: 0,
+                });
+                desiredTables.push({
+                    name: field.destinationDb.table,
+                    fields: [referenceIdFieldConfig.build(), selectIdFieldConfig.build()],
+                    sectionName: s.name,
+                    sectionType: 'destinationDb',
+                    identifier: undefined,
+                    /**
+                     * We can use both the referenceIdField and the selectIdField as a composite primary key
+                     * since they are unique together for each row
+                     */
+                    primaryKey: [referenceIdFieldConfig, selectIdFieldConfig],
+                });
+            }
+        }
+        /**
+         * Check for gallery
+         */
+        if (s.gallery?.db.tableName) {
+            console.log('Gallery found for section:', s.name, 'with table:', s.gallery.db.tableName);
+            const photoField = textField({
+                name: s.gallery.db.photoNameField || 'photo',
+                label: 'Photo Name',
+                required: true,
+                order: 0,
+            });
+            desiredTables.push({
+                name: s.gallery.db.tableName,
+                fields: [
+                    textField({
+                        name: s.gallery.db.referenceIdentifierField || 'reference_id',
+                        label: 'Reference Id',
+                        required: true,
+                        order: 0,
+                    }).build(),
+                    photoField.build(),
+                    textAreaField({
+                        name: s.gallery.db.metaField || 'meta',
+                        label: 'Photo Information',
+                        required: false,
+                        order: 0,
+                    }).build(),
+                ],
+                sectionName: s.name,
+                sectionType: 'gallery',
+                /**
+                 * We can use the photoField as the identifier for the gallery table
+                 * since it's unique, we can also use it as the primary key
+                 */
+                identifier: photoField,
+                primaryKey: [photoField],
+            });
+        }
+    }
+    /**
+     * Make sure the dynamic-schemas directory exists
+     */
+    if (!fs.existsSync('./dynamic-schemas')) {
+        fs.mkdirSync('./dynamic-schemas');
+    }
+    /**
+     * Append the Drizzle column types to the schema file
+     */
+    fs.appendFileSync(schemaFilePath, 'import {' + drizzleColumnTypes.join(',') + "} from 'drizzle-orm/mysql-core'\n\n");
+    /**
+     * Append the Drizzle table schemas to the schema file
+     */
+    fs.appendFileSync(schemaFilePath, drizzleTableSchemas.join('\n'));
+    s.stop();
+    console.log(chalk.white('Finding tables to create, update or remove...'));
+    s.start();
+    /**
+     * Filter out the tables that already exist in the database
+     */
+    const tablesToCreate = desiredTables.filter((table) => !existingTables.some((existingTable) => existingTable.name === table.name));
+    /**
+     * Let's find out tables that need to be updated.
+     * If a table exists in both the desired tables and the existing tables, we should mark it for update.
+     */
+    const tablesToUpdate = desiredTables.filter((table) => existingTables.some((existingTable) => existingTable.name === table.name));
+    /**
+     * Let's find out tables to remove as well.
+     * If a table exists in the database but not in the desired tables, we should mark it for removal.
+     */
+    let tablesToRemove = existingTables.filter((existingTable) => !desiredTables.some((table) => table.name === existingTable.name));
+    s.stop();
+    console.log('Desired tables:');
+    console.log(chalk.gray(desiredTables.map((table) => table.name).join(', ')));
+    console.log('Existing tables:');
+    console.log(chalk.gray(existingTables.map((table) => table.name).join(', ')));
+    console.log('Tables to update:');
+    console.log(chalk.gray(tablesToUpdate.map((table) => table.name).join(', ')));
+    console.log('Tables to create:');
+    console.log(chalk.gray(tablesToCreate.map((table) => table.name).join(', ')));
+    console.log('Tables to remove:');
+    console.log(chalk.gray(tablesToRemove.map((table) => table.name).join(', ')));
+    console.log(`\n`);
+    intro(chalk.inverse(' update-sections '));
+    /**
+     * Check if there are tables to update
+     */
+    if (tablesToUpdate.length > 0) {
+        /**
+         * Loop through the tables to update
+         */
+        for (const table of tablesToUpdate) {
+            await updateTable(table, s);
+        }
+    }
+    /**
+     * Check if there are tables to create
+     */
+    if (tablesToCreate.length > 0) {
+        console.log(chalk.bold.bgGreenBright(`There are ${tablesToCreate.length} table(s) to create:`));
+        /**
+         * Loop through the tables to create
+         */
+        for (const table of tablesToCreate) {
+            /**
+             * Check if there are tables to remove
+             * If there are, ask the user if they want to create the new table or rename a removed table
+             */
+            if (tablesToRemove.length > 0) {
+                s.stop();
+                const opType = await select({
+                    message: `Is table '${table.name}' for section '${table.sectionName}' a new table?`,
+                    options: [
+                        { value: 'new', label: 'Create new table' },
+                        { value: 'rename', label: 'Rename existing table' },
+                    ],
+                });
+                s.start();
+                switch (opType) {
+                    case 'new': {
+                        console.log(chalk.blueBright(`Creating table '${table.name}' for section '${table.sectionName}'`));
+                        let options = {
+                            createdAt: true,
+                            updatedAt: true,
+                            createdBy: true,
+                            updatedBy: true,
+                        };
+                        if (table.sectionType === 'simple') {
+                            options = {
+                                createdAt: false,
+                                updatedAt: true,
+                                createdBy: false,
+                                updatedBy: true,
+                            };
+                        }
+                        if (table.sectionType === 'gallery') {
+                            options = {
+                                updatedBy: false,
+                                updatedAt: false,
+                                createdBy: true,
+                                createdAt: true,
+                            };
+                        }
+                        if (table.sectionType === 'destinationDb, selectDb') {
+                            options = {
+                                createdAt: false,
+                                updatedAt: false,
+                                createdBy: false,
+                                updatedBy: false,
+                            };
+                        }
+                        await createTable(table, options);
+                        break;
+                    }
+                    case 'rename': {
+                        s.stop();
+                        const tableToRename = await select({
+                            message: `Select the table to rename to '${table.name}'`,
+                            options: tablesToRemove.map((table) => {
+                                return { value: table.name, label: table.name };
+                            }),
+                        });
+                        s.start();
+                        if (tableToRename && typeof tableToRename === 'string') {
+                            console.log(`Renaming table '${tableToRename}' to '${table.name}'`);
+                            await renameTable(tableToRename, table.name);
+                            await updateTable(table, s);
+                            /**
+                             * Remove the table from the tablesToRemove array
+                             */
+                            tablesToRemove = tablesToRemove.filter((table) => {
+                                return table.name !== tableToRename;
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+            else {
+                /*if (
+                    await confirm({
+                        message: `You are about to create a new table '${table.name}' for section '${table.sectionName}'. Proceed?`,
+                    })
+                ) {*/
+                console.log(chalk.blueBright(`Creating table '${table.name}' for section '${table.sectionName}'`));
+                let options = {
+                    createdAt: true,
+                    updatedAt: true,
+                    createdBy: true,
+                    updatedBy: true,
+                };
+                if (table.sectionType === 'simple') {
+                    options = {
+                        createdAt: false,
+                        updatedAt: true,
+                        createdBy: false,
+                        updatedBy: true,
+                    };
+                }
+                if (table.sectionType === 'gallery') {
+                    options = {
+                        updatedBy: false,
+                        updatedAt: false,
+                        createdBy: true,
+                        createdAt: true,
+                    };
+                }
+                if (table.sectionType === 'destinationDb') {
+                    options = {
+                        createdAt: false,
+                        updatedAt: false,
+                        createdBy: false,
+                        updatedBy: false,
+                    };
+                }
+                await createTable(table, options);
+                /*} else {
+                    console.log('Aborting...')
+                    return null
+                }*/
+            }
+        }
+    }
+    /**
+     * Finally, check if there are tables to remove
+     */
+    if (tablesToRemove.length > 0) {
+        console.log(chalk.red(`There are ${tablesToRemove.length} table(s) to remove:`));
+        console.log(chalk.red(`  - Warning: Removing a table will result in a permanent loss of its data!`));
+        /**
+         * Loop through the tables to remove
+         */
+        for (const table of tablesToRemove) {
+            s.stop();
+            const opType = await select({
+                message: `You are about to remove table '${table.name}'. Proceed?`,
+                options: [
+                    { value: 'yes', label: 'Yes, drop it' },
+                    { value: 'no', label: 'No, keep it' },
+                    { value: 'later', label: 'Ask me later' },
+                ],
+                initialValue: 'later',
+            });
+            s.start();
+            switch (opType) {
+                case 'yes':
+                case 'no':
+                    if (opType === 'yes') {
+                        console.log(chalk.gray(`  - Dropping table '${table.name}'`));
+                        await db.execute(sql `DROP TABLE \`${sql.raw(table.name)}\``);
+                    }
+                    else {
+                        console.log(chalk.gray(`  - Keeping table '${table.name}'`));
+                    }
+                    /**
+                     * Remove the table from the `__lz_tables` table
+                     */
+                    await db
+                        .delete(LZTablesTable)
+                        .where(eq(LZTablesTable.tableName, table.name))
+                        .catch((error) => {
+                        console.error('Error deleting from __lz_tables table:', error);
+                    });
+                    break;
+                case 'later':
+                    console.log(chalk.gray(`  - You will be asked next time for dropping table '${table.name}'`));
+                    break;
+            }
+        }
+    }
+};
+export async function updateSections(useDevEnv = false) {
+    const s = spinner();
+    try {
+        // s.start()
+        // Set environment file if dev mode
+        if (useDevEnv) {
+            process.env.NODE_ENV = 'development';
+        }
+        // Run the main update logic
+        await main(s);
+        s.stop('Sections updated successfully');
+    }
+    catch (error) {
+        s.stop('Failed to update sections');
+        throw error;
+    }
+}
+// TODO: Two things to do:
+// 1. Merge the createTable and updateTable functions into one function to also add the constraints while creating tables
+// 2. Add the foreign key constraints logic