nextjs-cms 0.9.16 → 0.9.18

package/dist/cli/lib/update-sections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/update-sections.ts"],"names":[],"mappings":"AA4wCA,wBAAsB,cAAc,CAAC,SAAS,UAAQ,iBAoBrD"}
+{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/update-sections.ts"],"names":[],"mappings":"AAirDA,wBAAsB,cAAc,CAAC,SAAS,UAAQ,iBAoBrD"}

package/dist/cli/lib/update-sections.js

@@ -51,6 +51,9 @@ function generateFieldSQL(input) {
             if (input.optionsType === 'static' && input.options) {
                 fieldSQL += `ENUM(${input.options.map((option) => `'${option.value}'`).join(', ')}) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`;
             }
+            else if (input.db?.identifierType === 'number') {
+                fieldSQL += 'INT(11)';
+            }
             else {
                 fieldSQL += 'VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci';
             }
@@ -228,6 +231,18 @@ function resolveCreateTableOptions(sectionType) {
             };
     }
 }
+const STORED_DEFAULT_LOCALE_KEY = 'localization.defaultLocale';
+async function readStoredDefaultLocale() {
+    const [rows] = await db.execute(sql `SELECT \`value\` FROM \`__nextjs_cms_config\` WHERE \`key\` = ${STORED_DEFAULT_LOCALE_KEY} LIMIT 1`);
+    const row = rows?.[0];
+    return row?.value ?? null;
+}
+async function writeStoredDefaultLocale(value) {
+    await db.execute(sql `INSERT INTO \`__nextjs_cms_config\` (\`key\`, \`value\`) VALUES (${STORED_DEFAULT_LOCALE_KEY}, ${value}) ON DUPLICATE KEY UPDATE \`value\` = ${value}`);
+}
+async function deleteStoredDefaultLocale() {
+    await db.execute(sql `DELETE FROM \`__nextjs_cms_config\` WHERE \`key\` = ${STORED_DEFAULT_LOCALE_KEY}`);
+}
 async function ensureTableRegistryEntry(tableName, sectionName) {
     await db
         .insert(NextJsCmsTablesTable)
@@ -355,7 +370,7 @@ async function renameTable(oldName, newName) {
         console.error(`Error renaming table \`${oldName}\` to \`${newName}\`:`, error);
     }
 }
-async function updateTable(table, s) {
+async function updateTable(table, s, ctx) {
     console.log();
     console.log(chalk.blueBright(`Updating table '${table.name}' for section '${table.sectionName}'`));
     s.start();
@@ -412,6 +427,30 @@ async function updateTable(table, s) {
             }
         }
     }
+    /**
+     * Special handling: if this is a destinationDb table and 'locale' is being added
+     * (either because localization was newly enabled OR a field was flipped to localized:true),
+     * run the 3-step migration inline so rows are backfilled with defaultLocale and the
+     * column ends up NOT NULL (required for the primary key to include it).
+     */
+    const defaultLocaleCode = ctx?.defaultLocaleCode ?? 'en';
+    const localeAddIndex = fieldsToAdd.findIndex((f) => f.name === 'locale');
+    if (table.sectionType === 'destinationDb' && localeAddIndex !== -1) {
+        const [localeField] = fieldsToAdd.splice(localeAddIndex, 1);
+        try {
+            await db.execute(sql `ALTER TABLE \`${sql.raw(table.name)}\` ADD COLUMN \`locale\` VARCHAR(10) DEFAULT NULL`);
+            await db.execute(sql `UPDATE \`${sql.raw(table.name)}\` SET \`locale\` = ${defaultLocaleCode} WHERE \`locale\` IS NULL`);
+            await db.execute(sql `ALTER TABLE \`${sql.raw(table.name)}\` MODIFY COLUMN \`locale\` VARCHAR(10) NOT NULL`);
+            log.info(chalk.gray(`  - Added 'locale' column to '${table.name}' and backfilled existing rows with '${defaultLocaleCode}'.`));
+        }
+        catch (error) {
+            sqlErrors++;
+            console.error(chalk.red(`  - Error migrating 'locale' column on '${table.name}':`, error));
+            // Restore to add-list so the generic ADD path still attempts if backfill failed
+            if (localeField)
+                fieldsToAdd.push(localeField);
+        }
+    }
     /**
      * Check if there are fields to add
      */
@@ -507,21 +546,24 @@ async function updateTable(table, s) {
      */
     if (table.sectionType === 'destinationDb' && fieldsToRemove.includes('locale')) {
         fieldsToRemove = fieldsToRemove.filter((f) => f !== 'locale');
-        s.stop();
-        const cmsConfig = await getCMSConfig();
-        const defaultLocaleCode = cmsConfig.localization?.defaultLocale ?? 'en';
-        const shouldDelocalize = await select({
-            message: `The 'locale' column in junction table '${table.name}' is no longer needed (field is no longer localized). This will:\n` +
-                `  1. Delete all non-default-locale rows (locale != '${defaultLocaleCode}')\n` +
-                `  2. Drop the 'locale' column from the table\n` +
-                `  3. Update the primary key to exclude 'locale'\n` +
-                `Proceed?`,
-            options: [
-                { value: 'no', label: 'No, keep the locale column' },
-                { value: 'yes', label: 'Yes, remove locale data and column' },
-            ],
-            initialValue: 'no',
-        });
+        // When localization was globally disabled, we already asked upfront — auto-confirm here.
+        let shouldDelocalize = ctx?.localizationTransition === 'disable' ? 'yes' : 'no';
+        if (ctx?.localizationTransition !== 'disable') {
+            s.stop();
+            shouldDelocalize = await select({
+                message: `The 'locale' column in junction table '${table.name}' is no longer needed (field is no longer localized). This will:\n` +
+                    `  1. Delete all non-default-locale rows (locale != '${defaultLocaleCode}')\n` +
+                    `  2. Drop the 'locale' column from the table\n` +
+                    `  3. Update the primary key to exclude 'locale'\n` +
+                    `Proceed?`,
+                options: [
+                    { value: 'no', label: 'No, keep the locale column' },
+                    { value: 'yes', label: 'Yes, remove locale data and column' },
+                ],
+                initialValue: 'no',
+            });
+            s.start();
+        }
         if (shouldDelocalize === 'yes') {
             try {
                 // Delete all non-default-locale rows
@@ -542,7 +584,6 @@ async function updateTable(table, s) {
         else {
             log.info(chalk.yellow(`- 'locale' column kept in '${table.name}'.`));
         }
-        s.start();
     }
     /**
      * Finally, check if there are fields to remove
@@ -637,12 +678,24 @@ const main = async (s) => {
      * Let's see if the table `__nextjs_cms_tables` exists in the database.
      * If it doesn't, we'll create it using the same schema as `NextJsCmsTablesTable`.
      */
-    await db.execute(sql `
-            CREATE TABLE IF NOT EXISTS __nextjs_cms_tables (
-                name VARCHAR(100) NOT NULL PRIMARY KEY,
-                section VARCHAR(200),
-                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
-            )
+    await db.execute(sql `
+            CREATE TABLE IF NOT EXISTS __nextjs_cms_tables (
+                name VARCHAR(100) NOT NULL PRIMARY KEY,
+                section VARCHAR(200),
+                created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+    /**
+     * Persistent key/value store for CMS-level state that must survive config removal —
+     * most importantly the original `localization.defaultLocale`, which we need to clean
+     * up locale-scoped rows correctly when localization is later disabled.
+     */
+    await db.execute(sql `
+            CREATE TABLE IF NOT EXISTS __nextjs_cms_config (
+                \`key\` VARCHAR(100) NOT NULL PRIMARY KEY,
+                \`value\` VARCHAR(255),
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+            )
         `);
     /**
      * Get the existing tables from the database
@@ -652,12 +705,41 @@ const main = async (s) => {
         name: NextJsCmsTablesTable.tableName,
     })
         .from(NextJsCmsTablesTable);
+    /**
+     * Reserved-name validation. Collected across all sections so the dev sees every
+     * conflict at once instead of fixing them one by one.
+     * Reserved: table suffix `_locales`, column name `locale`.
+     */
+    const RESERVED_TABLE_SUFFIX = '_locales';
+    const RESERVED_COLUMN_NAME = 'locale';
+    const reservedNameErrors = [];
     /**
      * Insert the sections into the database
      */
     for (const _s of sections) {
         const s = _s.build();
         s.buildFields();
+        if (s.db.table.endsWith(RESERVED_TABLE_SUFFIX)) {
+            reservedNameErrors.push(`Section '${s.name}': table name '${s.db.table}' ends with reserved suffix '${RESERVED_TABLE_SUFFIX}'.`);
+        }
+        for (const field of s.fields) {
+            if (field.name === RESERVED_COLUMN_NAME) {
+                reservedNameErrors.push(`Section '${s.name}', field '${field.name}': field name '${RESERVED_COLUMN_NAME}' is reserved.`);
+            }
+            if (field.destinationDb) {
+                if (field.destinationDb.table.endsWith(RESERVED_TABLE_SUFFIX)) {
+                    reservedNameErrors.push(`Section '${s.name}', field '${field.name}': destinationDb.table '${field.destinationDb.table}' ends with reserved suffix '${RESERVED_TABLE_SUFFIX}'.`);
+                }
+                if (field.destinationDb.itemIdentifier === RESERVED_COLUMN_NAME ||
+                    field.destinationDb.selectIdentifier === RESERVED_COLUMN_NAME) {
+                    reservedNameErrors.push(`Section '${s.name}', field '${field.name}': destinationDb identifier column name '${RESERVED_COLUMN_NAME}' is reserved.`);
+                }
+            }
+        }
+        const galleryForValidation = await s.getGallery();
+        if (galleryForValidation?.db.tableName && galleryForValidation.db.tableName.endsWith(RESERVED_TABLE_SUFFIX)) {
+            reservedNameErrors.push(`Section '${s.name}': gallery table '${galleryForValidation.db.tableName}' ends with reserved suffix '${RESERVED_TABLE_SUFFIX}'.`);
+        }
         /**
          * Generate the Drizzle schema for the table
          */
@@ -698,21 +780,36 @@ const main = async (s) => {
              */
             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,
-                });
+                const parentIdentifierType = s.db.identifier.type;
+                const referenceIdFieldConfig = parentIdentifierType === 'number'
+                    ? numberField({
+                        name: field.destinationDb.itemIdentifier,
+                        label: 'Reference Id',
+                        required: true,
+                        order: 0,
+                    })
+                    : textField({
+                        name: field.destinationDb.itemIdentifier,
+                        label: 'Reference Id',
+                        required: true,
+                        order: 0,
+                    });
+                const selectIdentifierType = is(field, SelectField) || is(field, SelectMultipleField)
+                    ? (field.db?.identifierType ?? 'text')
+                    : 'text';
+                const selectIdFieldConfig = selectIdentifierType === 'number'
+                    ? numberField({
+                        name: field.destinationDb.selectIdentifier,
+                        label: 'Select Id',
+                        required: true,
+                        order: 0,
+                    })
+                    : textField({
+                        name: field.destinationDb.selectIdentifier,
+                        label: 'Select Id',
+                        required: true,
+                        order: 0,
+                    });
                 /**
                  * If the field is localized, add a locale column to the destination table
                  * so that junction table values can be scoped per locale
@@ -722,7 +819,8 @@ const main = async (s) => {
                     ? textField({
                         name: 'locale',
                         label: 'Locale',
-                        required: false,
+                        required: true,
+                        maxLength: 10,
                         order: 0,
                     })
                     : undefined;
@@ -741,9 +839,17 @@ const main = async (s) => {
                     primaryKey: primaryKeyFields,
                 });
                 const destDbFields = [
-                    { name: field.destinationDb.itemIdentifier, type: 'text', required: true },
-                    { name: field.destinationDb.selectIdentifier, type: 'text', required: true },
-                    ...(isLocalized ? [{ name: 'locale', type: 'text', required: false }] : []),
+                    {
+                        name: field.destinationDb.itemIdentifier,
+                        type: parentIdentifierType,
+                        required: true,
+                    },
+                    {
+                        name: field.destinationDb.selectIdentifier,
+                        type: selectIdentifierType,
+                        required: true,
+                    },
+                    ...(isLocalized ? [{ name: 'locale', type: 'text', required: true }] : []),
                 ];
                 const destDbSchema = generateDrizzleSchema({
                     name: field.destinationDb.table,
@@ -768,15 +874,23 @@ const main = async (s) => {
                 required: true,
                 order: 0,
             });
+            const galleryRefField = s.db.identifier.type === 'number'
+                ? numberField({
+                    name: gallery.db.referenceIdentifierField || 'reference_id',
+                    label: 'Reference Id',
+                    required: true,
+                    order: 0,
+                })
+                : textField({
+                    name: gallery.db.referenceIdentifierField || 'reference_id',
+                    label: 'Reference Id',
+                    required: true,
+                    order: 0,
+                });
             desiredTables.push({
                 name: gallery.db.tableName,
                 fields: [
-                    textField({
-                        name: gallery.db.referenceIdentifierField || 'reference_id',
-                        label: 'Reference Id',
-                        required: true,
-                        order: 0,
-                    }).build(),
+                    galleryRefField.build(),
                     photoField.build(),
                     textAreaField({
                         name: gallery.db.metaField || 'meta',
@@ -799,7 +913,7 @@ const main = async (s) => {
                 fields: [
                     {
                         name: gallery.db.referenceIdentifierField || 'reference_id',
-                        type: 'text',
+                        type: s.db.identifier.type,
                         required: true,
                     },
                     {
@@ -880,6 +994,15 @@ const main = async (s) => {
             localesSchema.drizzleImports.forEach((type) => drizzleImports.add(type));
         }
     }
+    /**
+     * Reject the run before any DB write if any section used a reserved name.
+     */
+    if (reservedNameErrors.length > 0) {
+        s.stop(`update-sections aborted: ${reservedNameErrors.length} reserved-name conflict(s) detected.\n` +
+            reservedNameErrors.map((e) => `  - ${e}`).join('\n') +
+            `\n\nThe suffix '${RESERVED_TABLE_SUFFIX}' and the column name '${RESERVED_COLUMN_NAME}' are reserved for the localization system. Please rename and re-run.`);
+        throw new Error('update-sections: reserved name conflicts detected');
+    }
     /**
      * Write schema file if schema generation is enabled
      */
@@ -929,6 +1052,185 @@ const main = async (s) => {
     console.log(chalk.gray(tablesToRemove.map((table) => table.name).join(', ')));
     console.log(`\n`);
     intro(chalk.inverse(' update-sections '));
+    /**
+     * Detect localization transition by inspecting 'editor_photos' — the presence of its 'locale'
+     * column reflects whether localization was enabled on the previous run. Pair this with the
+     * stored `localization.defaultLocale` from `__nextjs_cms_config` so destructive cleanup uses
+     * the correct locale (the one actually used to tag existing rows), not a guess from the
+     * now-missing config.
+     */
+    const localizationCurrentlyEnabled = cmsConfig.localization?.enabled === true;
+    const configDefaultLocale = cmsConfig.localization?.defaultLocale;
+    const editorPhotosColumns = await MysqlTableChecker.getColumns('editor_photos').catch(() => []);
+    const editorPhotosExists = editorPhotosColumns.length > 0;
+    const editorPhotosHasLocale = editorPhotosColumns.includes('locale');
+    const storedDefaultLocale = await readStoredDefaultLocale();
+    // Detect residual `locale` columns on registered tables. Used to resume an interrupted
+    // disable flow: if editor_photos is already cleaned but a junction still carries the
+    // column, the upfront disable path must fire again so cleanup uses the stored locale.
+    let hasResidualLocaleColumn = false;
+    if (!localizationCurrentlyEnabled && !editorPhotosHasLocale && storedDefaultLocale) {
+        for (const existing of existingTables) {
+            const cols = await MysqlTableChecker.getColumns(existing.name).catch(() => []);
+            if (cols.includes('locale')) {
+                hasResidualLocaleColumn = true;
+                break;
+            }
+        }
+    }
+    let localizationTransition = null;
+    /**
+     * Enforcement: on steady-state enabled runs, disallow silent changes to `defaultLocale`.
+     * If a mismatch is detected, abort before any destructive operation.
+     */
+    if (localizationCurrentlyEnabled && editorPhotosHasLocale) {
+        if (storedDefaultLocale && configDefaultLocale && storedDefaultLocale !== configDefaultLocale) {
+            s.stop(`Aborting. Changing 'localization.defaultLocale' is not supported (stored='${storedDefaultLocale}', config='${configDefaultLocale}'). Revert cms.config.ts and re-run update-sections.`);
+            return;
+        }
+        if (!storedDefaultLocale && configDefaultLocale) {
+            // Seed the stored value from current config — one-time backfill for installs that
+            // predate `__nextjs_cms_config`.
+            await writeStoredDefaultLocale(configDefaultLocale);
+        }
+    }
+    // Resolve the locale used for cleanup SQL. For newly-disabled, stored takes precedence;
+    // for newly-enabled, config is the source of truth.
+    const defaultLocaleCode = localizationCurrentlyEnabled
+        ? (configDefaultLocale ?? storedDefaultLocale ?? 'en')
+        : (storedDefaultLocale ?? configDefaultLocale ?? 'en');
+    if (editorPhotosExists && localizationCurrentlyEnabled && !editorPhotosHasLocale) {
+        /**
+         * Localization is newly enabled: editor_photos lacks the locale column,
+         * but the config now has localization.enabled = true. We must backfill
+         * editor_photos and any existing junction tables that carry localized data
+         * with the configured defaultLocale.
+         */
+        const affectedJunctions = [];
+        for (const t of desiredTables) {
+            if (t.sectionType !== 'destinationDb')
+                continue;
+            if (!t.fields.some((f) => f.name === 'locale'))
+                continue;
+            const cols = await MysqlTableChecker.getColumns(t.name).catch(() => []);
+            if (cols.length > 0 && !cols.includes('locale')) {
+                affectedJunctions.push(t.name);
+            }
+        }
+        const affectedList = ['editor_photos', ...affectedJunctions];
+        s.stop();
+        const confirm = await select({
+            message: `It looks like you enabled localization. Your existing data in these tables will be marked as defaultLocale '${defaultLocaleCode}':\n` +
+                affectedList.map((n) => `  - ${n}`).join('\n') +
+                `\n\n${chalk.redBright('WARNING:')} Existing data in these tables MUST already be in '${defaultLocaleCode}'. ` +
+                `Changing defaultLocale after this point is not supported. If your data is not in '${defaultLocaleCode}', ` +
+                `stop now and fix your cms.config.ts before re-running update-sections.\n\nProceed?`,
+            options: [
+                { value: 'yes', label: `Yes, that's correct` },
+                { value: 'no', label: 'No, stop — let me reconfigure localization in cms.config.ts' },
+            ],
+            initialValue: 'no',
+        });
+        if (confirm !== 'yes') {
+            s.stop('Aborted. Reconfigure cms.config.ts and re-run update-sections.');
+            return;
+        }
+        localizationTransition = 'enable';
+        try {
+            await db.execute(sql `ALTER TABLE \`editor_photos\` ADD COLUMN \`locale\` VARCHAR(10) DEFAULT NULL`);
+            await db.execute(sql `UPDATE \`editor_photos\` SET \`locale\` = ${defaultLocaleCode} WHERE \`locale\` IS NULL`);
+            await db.execute(sql `ALTER TABLE \`editor_photos\` MODIFY COLUMN \`locale\` VARCHAR(10) NOT NULL`);
+            // Persist the defaultLocale so future disable cleanup uses the right filter even
+            // after `localization` is stripped from cms.config.ts.
+            await writeStoredDefaultLocale(defaultLocaleCode);
+            log.info(chalk.gray(`  - Added 'locale' column to 'editor_photos' and backfilled existing rows with '${defaultLocaleCode}'.`));
+        }
+        catch (error) {
+            console.error(chalk.red(`  - Error migrating 'editor_photos' for localization enable:`, error));
+        }
+        s.start();
+    }
+    else if (editorPhotosExists &&
+        !localizationCurrentlyEnabled &&
+        (editorPhotosHasLocale || hasResidualLocaleColumn)) {
+        /**
+         * Localization is newly disabled (or a previous disable run was interrupted):
+         * editor_photos or some junction/_locales table still carries the locale column,
+         * but the config no longer has localization.enabled = true. We purge non-default rows
+         * (and their files), drop the locale column from editor_photos and junction tables,
+         * and drop _locales tables. The deletion filter uses the STORED defaultLocale (not
+         * config, which may be missing), so rows tagged with the original base locale survive
+         * regardless of current config.
+         */
+        if (!storedDefaultLocale) {
+            s.stop(`Aborting. Cannot disable localization safely: no stored defaultLocale found in '__nextjs_cms_config'. This indicates a corrupted state.`);
+            return;
+        }
+        const affected = [
+            { name: 'editor_photos', type: 'editor_photos' },
+        ];
+        for (const existing of existingTables) {
+            if (existing.name === 'editor_photos')
+                continue;
+            const cols = await MysqlTableChecker.getColumns(existing.name).catch(() => []);
+            if (!cols.includes('locale'))
+                continue;
+            if (existing.name.endsWith('_locales')) {
+                affected.push({ name: existing.name, type: 'locales' });
+            }
+            else {
+                affected.push({ name: existing.name, type: 'junction' });
+            }
+        }
+        s.stop();
+        const confirm = await select({
+            message: `It looks like you disabled localization. The 'locale' column in the tables below is no longer needed and will be dropped.\n\n` +
+                `Base locale (from '__nextjs_cms_config'): '${storedDefaultLocale}'. Rows tagged with this locale will be kept; all others will be deleted.\n\n` +
+                `This will:\n` +
+                `  1. Delete all non-base-locale rows (locale != '${storedDefaultLocale}') from editor_photos and junction tables (their files on disk will also be removed)\n` +
+                `  2. Drop the 'locale' column from editor_photos and junction tables\n` +
+                `  3. Drop '_locales' tables entirely\n\n` +
+                `Affected tables:\n` +
+                affected.map((t) => `  - ${t.name} (${t.type})`).join('\n') +
+                `\n\nProceed?`,
+            options: [
+                { value: 'yes', label: `Yes, that's correct` },
+                { value: 'no', label: 'No, stop — let me reconfigure localization in cms.config.ts' },
+            ],
+            initialValue: 'no',
+        });
+        if (confirm !== 'yes') {
+            s.stop('Aborted. Reconfigure cms.config.ts and re-run update-sections.');
+            return;
+        }
+        localizationTransition = 'disable';
+        if (editorPhotosHasLocale) {
+            try {
+                const uploadsFolder = cmsConfig.media.upload.path;
+                const [nondefaultRows] = await db.execute(sql `SELECT \`photo\`, \`section\` FROM \`editor_photos\` WHERE \`locale\` != ${storedDefaultLocale}`);
+                const rows = nondefaultRows ?? [];
+                for (const row of rows) {
+                    try {
+                        await fs.promises.unlink(path.join(uploadsFolder, '.photos', row.section, row.photo));
+                    }
+                    catch {
+                        // ignore missing files
+                    }
+                }
+                await db.execute(sql `DELETE FROM \`editor_photos\` WHERE \`locale\` != ${storedDefaultLocale}`);
+                await db.execute(sql `ALTER TABLE \`editor_photos\` DROP COLUMN \`locale\``);
+                log.info(chalk.gray(`  - Removed ${rows.length} non-base-locale row(s) and dropped 'locale' column from 'editor_photos'.`));
+            }
+            catch (error) {
+                console.error(chalk.red(`  - Error migrating 'editor_photos' for localization disable:`, error));
+            }
+        }
+        else {
+            log.info(chalk.gray(`  - 'editor_photos' already delocalized; resuming junction/_locales cleanup.`));
+        }
+        s.start();
+    }
+    const ctx = { localizationTransition, defaultLocaleCode };
     /**
      * Check if there are tables to update
      */
@@ -937,7 +1239,7 @@ const main = async (s) => {
          * Loop through the tables to update
          */
         for (const table of tablesToUpdate) {
-            await updateTable(table, s);
+            await updateTable(table, s, ctx);
         }
     }
     /**
@@ -962,7 +1264,7 @@ const main = async (s) => {
                 });
                 if (overwriteExistingTable === 'yes') {
                     await ensureTableRegistryEntry(table.name, table.sectionName);
-                    await updateTable(table, s);
+                    await updateTable(table, s, ctx);
                 }
                 else {
                     console.log(chalk.yellow(`Skipping existing table '${table.name}'.`));
@@ -1001,7 +1303,7 @@ const main = async (s) => {
                         if (tableToRename && typeof tableToRename === 'string') {
                             console.log(`Renaming table '${tableToRename}' to '${table.name}'`);
                             await renameTable(tableToRename, table.name);
-                            await updateTable(table, s);
+                            await updateTable(table, s, ctx);
                             /**
                              * Remove the table from the tablesToRemove array
                              */
@@ -1039,17 +1341,26 @@ const main = async (s) => {
          * 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();
+            // When localization was globally disabled, auto-confirm dropping _locales tables —
+            // the upfront prompt already covered them.
+            const autoDropLocales = localizationTransition === 'disable' && table.name.endsWith('_locales') ? 'yes' : null;
+            let opType;
+            if (autoDropLocales) {
+                opType = autoDropLocales;
+            }
+            else {
+                s.stop();
+                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':
@@ -1076,6 +1387,50 @@ const main = async (s) => {
             }
         }
     }
+    /**
+     * Only now — after every junction update and every `_locales` drop has been attempted —
+     * is it safe to clear the stored defaultLocale. The individual cleanup steps swallow
+     * errors to keep the run going, so "transition === 'disable'" is not by itself proof the
+     * DB is clean. Post-check the actual state: editor_photos must have no `locale` column,
+     * and no registered table (junction or `_locales`) may still carry one. If any trace
+     * remains, keep the stored value so the next run can resume with the correct filter.
+     */
+    if (localizationTransition === 'disable') {
+        const postEditorPhotosCols = await MysqlTableChecker.getColumns('editor_photos').catch(() => []);
+        let fullyClean = !postEditorPhotosCols.includes('locale');
+        if (!fullyClean) {
+            log.warn(chalk.yellow(`  - 'editor_photos' still has a 'locale' column after cleanup. Keeping stored defaultLocale so the next run can resume.`));
+        }
+        const postRegistered = fullyClean
+            ? await db.select({ name: NextJsCmsTablesTable.tableName }).from(NextJsCmsTablesTable)
+            : [];
+        if (fullyClean) {
+            for (const t of postRegistered) {
+                const cols = await MysqlTableChecker.getColumns(t.name).catch(() => []);
+                if (cols.includes('locale')) {
+                    fullyClean = false;
+                    log.warn(chalk.yellow(`  - Table '${t.name}' still has a 'locale' column after cleanup. Keeping stored defaultLocale so the next run can resume.`));
+                    break;
+                }
+            }
+        }
+        if (fullyClean) {
+            // Check registered tables whose name ends with '_locales' — scoped to
+            // __nextjs_cms_tables so unrelated tables sharing the DB are never flagged.
+            const registeredLocalesTables = postRegistered.filter((t) => t.name.endsWith('_locales'));
+            for (const t of registeredLocalesTables) {
+                const stillExists = (await MysqlTableChecker.getExistingTableStructure(t.name)) !== null;
+                if (stillExists) {
+                    fullyClean = false;
+                    log.warn(chalk.yellow(`  - Registered '_locales' table '${t.name}' still exists after cleanup. Keeping stored defaultLocale so the next run can resume.`));
+                    break;
+                }
+            }
+        }
+        if (fullyClean) {
+            await deleteStoredDefaultLocale();
+        }
+    }
 };
 export async function updateSections(useDevEnv = false) {
     const s = spinner();

package/dist/cli/utils/schema-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/schema-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAoB7D,MAAM,WAAW,YAAY;IACzB,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACzC,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAC7C;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;IAChD,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;CACpD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CA8BtE;AAED,wBAAgB,qBAAqB,CACjC,KAAK,EAAE;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,mBAAmB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACxC,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACxD,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzD,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC9D,EACD,YAAY,EAAE,YAAY,GAC3B;IACC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,EAAE,CAAA;CAC3B,CA4LA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE;IACJ,eAAe,EAAE,MAAM,CAAA;IACvB,gBAAgB,EAAE,WAAW,CAAA;IAC7B,eAAe,EAAE,WAAW,EAAE,CAAA;IAC9B,YAAY,EAAE,YAAY,CAAA;CAC7B,GACF;IACC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,EAAE,CAAA;CAC3B,CAoCA"}
+{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/schema-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAoB7D,MAAM,WAAW,YAAY;IACzB,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACzC,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAC7C;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;IAChD,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;CACpD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CA8BtE;AAED,wBAAgB,qBAAqB,CACjC,KAAK,EAAE;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,mBAAmB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACxC,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACxD,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzD,QAAQ,CAAC,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC9D,EACD,YAAY,EAAE,YAAY,GAC3B;IACC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,EAAE,CAAA;CAC3B,CA4MA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IAC/C,eAAe,EAAE,MAAM,CAAA;IACvB,gBAAgB,EAAE,WAAW,CAAA;IAC7B,eAAe,EAAE,WAAW,EAAE,CAAA;IAC9B,YAAY,EAAE,YAAY,CAAA;CAC7B,GAAG;IACA,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,EAAE,CAAA;CAC3B,CA+CA"}