@strapi/content-type-builder 5.56.0 → 5.58.0

package/dist/server/services/schema-mutation.mjs

@@ -1,3 +1,5 @@
+import * as fse from 'fs-extra';
+
 const finalizeSchemaMutation = async ({ apiHandler, backedUpApiUids = [] })=>{
     const errors = [];
     for (const uid of backedUpApiUids){
@@ -10,10 +12,11 @@ const finalizeSchemaMutation = async ({ apiHandler, backedUpApiUids = [] })=>{
     return errors;
 };
 /**
- * Restores the filesystem artifacts touched before content-structure reconciliation.
+ * Restores the filesystem artifacts touched before content-structure reconciliation: the
+ * generated rename migration, generated APIs, the schema files and API backups.
  * Folder reconciliation is deliberately the final mutation, so groups.json never needs a
  * compensating write when an earlier schema or API operation fails.
- */ const rollbackSchemaMutation = async ({ builder, apiHandler, backedUpApiUids = [], generatedApiNames = [], schemaAlreadyRolledBack = false })=>{
+ */ const rollbackSchemaMutation = async ({ builder, apiHandler, backedUpApiUids = [], generatedApiNames = [], schemaAlreadyRolledBack = false, migrationFilePath = null })=>{
     const errors = [];
     const attempt = async (operation)=>{
         try {
@@ -22,6 +25,11 @@ const finalizeSchemaMutation = async ({ apiHandler, backedUpApiUids = [] })=>{
             errors.push(error);
         }
     };
+    // The rename migration is written before the schema files. Remove it first so a rejected
+    // save never leaves a migration that would rename columns on the next boot.
+    if (migrationFilePath) {
+        await attempt(()=>fse.remove(migrationFilePath));
+    }
     // A generator can fail before a schema directory exists, so remove its partial API before
     // asking the schema handler to roll back. Every action is attempted even if an earlier one
     // fails, ensuring compensation is best-effort rather than short-circuiting.

package/dist/server/services/schema-mutation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"schema-mutation.mjs","sources":["../../../server/src/services/schema-mutation.ts"],"sourcesContent":["type SchemaBuilder = {\n  rollback(): Promise<unknown>;\n};\n\ntype ApiHandler = {\n  rollback(uid: string): Promise<void>;\n  clearGenerated(apiName: string): Promise<void>;\n  finalize(uid: string): Promise<void>;\n};\n\nexport const finalizeSchemaMutation = async ({\n  apiHandler,\n  backedUpApiUids = [],\n}: {\n  apiHandler: ApiHandler;\n  backedUpApiUids?: string[];\n}) => {\n  const errors: unknown[] = [];\n\n  for (const uid of backedUpApiUids) {\n    try {\n      await apiHandler.finalize(uid);\n    } catch (error) {\n      errors.push(error);\n    }\n  }\n\n  return errors;\n};\n\n/**\n * Restores the filesystem artifacts touched before content-structure reconciliation.\n * Folder reconciliation is deliberately the final mutation, so groups.json never needs a\n * compensating write when an earlier schema or API operation fails.\n */\nexport const rollbackSchemaMutation = async ({\n  builder,\n  apiHandler,\n  backedUpApiUids = [],\n  generatedApiNames = [],\n  schemaAlreadyRolledBack = false,\n}: {\n  builder: SchemaBuilder;\n  apiHandler: ApiHandler;\n  backedUpApiUids?: string[];\n  generatedApiNames?: string[];\n  schemaAlreadyRolledBack?: boolean;\n}) => {\n  const errors: unknown[] = [];\n  const attempt = async (operation: () => Promise<unknown>) => {\n    try {\n      await operation();\n    } catch (error) {\n      errors.push(error);\n    }\n  };\n\n  // A generator can fail before a schema directory exists, so remove its partial API before\n  // asking the schema handler to roll back. Every action is attempted even if an earlier one\n  // fails, ensuring compensation is best-effort rather than short-circuiting.\n  for (const apiName of generatedApiNames) {\n    await attempt(() => apiHandler.clearGenerated(apiName));\n  }\n\n  if (!schemaAlreadyRolledBack) {\n    await attempt(() => builder.rollback());\n  }\n\n  for (const uid of backedUpApiUids) {\n    await attempt(() => apiHandler.rollback(uid));\n  }\n\n  if (errors.length > 0) {\n    throw errors[0];\n  }\n};\n"],"names":["finalizeSchemaMutation","apiHandler","backedUpApiUids","errors","uid","finalize","error","push","rollbackSchemaMutation","builder","generatedApiNames","schemaAlreadyRolledBack","attempt","operation","apiName","clearGenerated","rollback","length"],"mappings":"AAUO,MAAMA,yBAAyB,OAAO,EAC3CC,UAAU,EACVC,eAAAA,GAAkB,EAAE,EAIrB,GAAA;AACC,IAAA,MAAMC,SAAoB,EAAE;IAE5B,KAAK,MAAMC,OAAOF,eAAAA,CAAiB;QACjC,IAAI;YACF,MAAMD,UAAAA,CAAWI,QAAQ,CAACD,GAAAA,CAAAA;AAC5B,QAAA,CAAA,CAAE,OAAOE,KAAAA,EAAO;AACdH,YAAAA,MAAAA,CAAOI,IAAI,CAACD,KAAAA,CAAAA;AACd,QAAA;AACF,IAAA;IAEA,OAAOH,MAAAA;AACT;AAEA;;;;AAIC,IACM,MAAMK,sBAAAA,GAAyB,OAAO,EAC3CC,OAAO,EACPR,UAAU,EACVC,eAAAA,GAAkB,EAAE,EACpBQ,iBAAAA,GAAoB,EAAE,EACtBC,uBAAAA,GAA0B,KAAK,EAOhC,GAAA;AACC,IAAA,MAAMR,SAAoB,EAAE;AAC5B,IAAA,MAAMS,UAAU,OAAOC,SAAAA,GAAAA;QACrB,IAAI;YACF,MAAMA,SAAAA,EAAAA;AACR,QAAA,CAAA,CAAE,OAAOP,KAAAA,EAAO;AACdH,YAAAA,MAAAA,CAAOI,IAAI,CAACD,KAAAA,CAAAA;AACd,QAAA;AACF,IAAA,CAAA;;;;IAKA,KAAK,MAAMQ,WAAWJ,iBAAAA,CAAmB;AACvC,QAAA,MAAME,OAAAA,CAAQ,IAAMX,UAAAA,CAAWc,cAAc,CAACD,OAAAA,CAAAA,CAAAA;AAChD,IAAA;AAEA,IAAA,IAAI,CAACH,uBAAAA,EAAyB;QAC5B,MAAMC,OAAAA,CAAQ,IAAMH,OAAAA,CAAQO,QAAQ,EAAA,CAAA;AACtC,IAAA;IAEA,KAAK,MAAMZ,OAAOF,eAAAA,CAAiB;AACjC,QAAA,MAAMU,OAAAA,CAAQ,IAAMX,UAAAA,CAAWe,QAAQ,CAACZ,GAAAA,CAAAA,CAAAA;AAC1C,IAAA;IAEA,IAAID,MAAAA,CAAOc,MAAM,GAAG,CAAA,EAAG;QACrB,MAAMd,MAAM,CAAC,CAAA,CAAE;AACjB,IAAA;AACF;;;;"}
+{"version":3,"file":"schema-mutation.mjs","sources":["../../../server/src/services/schema-mutation.ts"],"sourcesContent":["import * as fse from 'fs-extra';\n\ntype SchemaBuilder = {\n  rollback(): Promise<unknown>;\n};\n\ntype ApiHandler = {\n  rollback(uid: string): Promise<void>;\n  clearGenerated(apiName: string): Promise<void>;\n  finalize(uid: string): Promise<void>;\n};\n\nexport const finalizeSchemaMutation = async ({\n  apiHandler,\n  backedUpApiUids = [],\n}: {\n  apiHandler: ApiHandler;\n  backedUpApiUids?: string[];\n}) => {\n  const errors: unknown[] = [];\n\n  for (const uid of backedUpApiUids) {\n    try {\n      await apiHandler.finalize(uid);\n    } catch (error) {\n      errors.push(error);\n    }\n  }\n\n  return errors;\n};\n\n/**\n * Restores the filesystem artifacts touched before content-structure reconciliation: the\n * generated rename migration, generated APIs, the schema files and API backups.\n * Folder reconciliation is deliberately the final mutation, so groups.json never needs a\n * compensating write when an earlier schema or API operation fails.\n */\nexport const rollbackSchemaMutation = async ({\n  builder,\n  apiHandler,\n  backedUpApiUids = [],\n  generatedApiNames = [],\n  schemaAlreadyRolledBack = false,\n  migrationFilePath = null,\n}: {\n  builder: SchemaBuilder;\n  apiHandler: ApiHandler;\n  backedUpApiUids?: string[];\n  generatedApiNames?: string[];\n  schemaAlreadyRolledBack?: boolean;\n  migrationFilePath?: string | null;\n}) => {\n  const errors: unknown[] = [];\n  const attempt = async (operation: () => Promise<unknown>) => {\n    try {\n      await operation();\n    } catch (error) {\n      errors.push(error);\n    }\n  };\n\n  // The rename migration is written before the schema files. Remove it first so a rejected\n  // save never leaves a migration that would rename columns on the next boot.\n  if (migrationFilePath) {\n    await attempt(() => fse.remove(migrationFilePath));\n  }\n\n  // A generator can fail before a schema directory exists, so remove its partial API before\n  // asking the schema handler to roll back. Every action is attempted even if an earlier one\n  // fails, ensuring compensation is best-effort rather than short-circuiting.\n  for (const apiName of generatedApiNames) {\n    await attempt(() => apiHandler.clearGenerated(apiName));\n  }\n\n  if (!schemaAlreadyRolledBack) {\n    await attempt(() => builder.rollback());\n  }\n\n  for (const uid of backedUpApiUids) {\n    await attempt(() => apiHandler.rollback(uid));\n  }\n\n  if (errors.length > 0) {\n    throw errors[0];\n  }\n};\n"],"names":["finalizeSchemaMutation","apiHandler","backedUpApiUids","errors","uid","finalize","error","push","rollbackSchemaMutation","builder","generatedApiNames","schemaAlreadyRolledBack","migrationFilePath","attempt","operation","fse","remove","apiName","clearGenerated","rollback","length"],"mappings":";;AAYO,MAAMA,yBAAyB,OAAO,EAC3CC,UAAU,EACVC,eAAAA,GAAkB,EAAE,EAIrB,GAAA;AACC,IAAA,MAAMC,SAAoB,EAAE;IAE5B,KAAK,MAAMC,OAAOF,eAAAA,CAAiB;QACjC,IAAI;YACF,MAAMD,UAAAA,CAAWI,QAAQ,CAACD,GAAAA,CAAAA;AAC5B,QAAA,CAAA,CAAE,OAAOE,KAAAA,EAAO;AACdH,YAAAA,MAAAA,CAAOI,IAAI,CAACD,KAAAA,CAAAA;AACd,QAAA;AACF,IAAA;IAEA,OAAOH,MAAAA;AACT;AAEA;;;;;UAMaK,sBAAAA,GAAyB,OAAO,EAC3CC,OAAO,EACPR,UAAU,EACVC,eAAAA,GAAkB,EAAE,EACpBQ,iBAAAA,GAAoB,EAAE,EACtBC,uBAAAA,GAA0B,KAAK,EAC/BC,iBAAAA,GAAoB,IAAI,EAQzB,GAAA;AACC,IAAA,MAAMT,SAAoB,EAAE;AAC5B,IAAA,MAAMU,UAAU,OAAOC,SAAAA,GAAAA;QACrB,IAAI;YACF,MAAMA,SAAAA,EAAAA;AACR,QAAA,CAAA,CAAE,OAAOR,KAAAA,EAAO;AACdH,YAAAA,MAAAA,CAAOI,IAAI,CAACD,KAAAA,CAAAA;AACd,QAAA;AACF,IAAA,CAAA;;;AAIA,IAAA,IAAIM,iBAAAA,EAAmB;AACrB,QAAA,MAAMC,OAAAA,CAAQ,IAAME,GAAAA,CAAIC,MAAM,CAACJ,iBAAAA,CAAAA,CAAAA;AACjC,IAAA;;;;IAKA,KAAK,MAAMK,WAAWP,iBAAAA,CAAmB;AACvC,QAAA,MAAMG,OAAAA,CAAQ,IAAMZ,UAAAA,CAAWiB,cAAc,CAACD,OAAAA,CAAAA,CAAAA;AAChD,IAAA;AAEA,IAAA,IAAI,CAACN,uBAAAA,EAAyB;QAC5B,MAAME,OAAAA,CAAQ,IAAMJ,OAAAA,CAAQU,QAAQ,EAAA,CAAA;AACtC,IAAA;IAEA,KAAK,MAAMf,OAAOF,eAAAA,CAAiB;AACjC,QAAA,MAAMW,OAAAA,CAAQ,IAAMZ,UAAAA,CAAWkB,QAAQ,CAACf,GAAAA,CAAAA,CAAAA;AAC1C,IAAA;IAEA,IAAID,MAAAA,CAAOiB,MAAM,GAAG,CAAA,EAAG;QACrB,MAAMjB,MAAM,CAAC,CAAA,CAAE;AACjB,IAAA;AACF;;;;"}

package/dist/server/services/schema.js

@@ -1,10 +1,12 @@
 'use strict';
 
 var utils = require('@strapi/utils');
-var fp = require('lodash/fp');
-var index = require('./schema-builder/index.js');
+var _ = require('lodash');
+var index$1 = require('./schema-builder/index.js');
+var index = require('./migration-builder/index.js');
 var schemaMutation = require('./schema-mutation.js');
-var index$1 = require('../utils/index.js');
+var index$2 = require('../utils/index.js');
+var schema = require('../controllers/validation/schema.js');
 var contentTypes = require('./content-types.js');
 
 const removeEmptyDefaultsOnUpdates = (schema)=>{
@@ -50,6 +52,290 @@ const removeDeletedUIDTargetFieldsOnUpdates = (schema)=>{
         });
     });
 };
+/**
+ * Composes the ordered rename hops of an updated type into an origin -> final
+ * name map (`a -> b, b -> c` gives `a -> c`).
+ */ const composeRenames = (hops)=>{
+    const originByName = new Map();
+    hops.forEach(({ oldName, newName })=>{
+        if (!oldName || !newName || oldName === newName) {
+            return;
+        }
+        const origin = originByName.get(oldName) ?? oldName;
+        originByName.delete(oldName);
+        originByName.set(newName, origin);
+    });
+    return new Map([
+        ...originByName
+    ].map(([name, origin])=>[
+            origin,
+            name
+        ]));
+};
+/**
+ * Makes field conditions follow the renames of this save: a condition whose
+ * `var` still names the origin of a rename is pointed at the field's final name.
+ *
+ * A `var` that names an attribute of the saved type is left alone: the caller
+ * already rewrote it, or (in a swap) it cannot be told apart from one that was.
+ */ const renameConditionVarsOnUpdates = (schema)=>{
+    const entries = [
+        ...schema.contentTypes,
+        ...schema.components
+    ];
+    entries.forEach((entry)=>{
+        if (entry.action !== 'update' || !Array.isArray(entry.renames)) {
+            return;
+        }
+        const renames = composeRenames(entry.renames);
+        const savedAttributes = (entry.attributes ?? []).filter((attribute)=>attribute.action !== 'delete');
+        const saved = new Set(savedAttributes.map((attribute)=>attribute.name));
+        savedAttributes.forEach((attribute)=>{
+            Object.values(attribute.properties?.conditions?.visible ?? {}).forEach((rule)=>{
+                const fieldVar = Array.isArray(rule) ? rule[0] : undefined;
+                if (typeof fieldVar !== 'object' || fieldVar === null || !('var' in fieldVar) || typeof fieldVar.var !== 'string' || saved.has(fieldVar.var)) {
+                    return;
+                }
+                const finalName = renames.get(fieldVar.var);
+                if (finalName !== undefined && saved.has(finalName)) {
+                    fieldVar.var = finalName;
+                }
+            });
+        });
+    });
+};
+const getAttributeRenameMigrationMode = ()=>{
+    return strapi.plugin('content-type-builder').config('renameMigrations.attributes', 'prompt-before-save');
+};
+/**
+ * Collects attribute renames from the update-schema payload. The admin sends an
+ * ordered `renames` array per updated content-type / component: the exact path
+ * of rename hops the user performed (e.g. `a -> tmp`, `b -> a`, `tmp -> b` for a
+ * swap). Order is preserved so the generated migration can replay each hop
+ * verbatim — which is inherently collision-free because the Content-Type Builder
+ * never allows two fields to share a name at any instant.
+ */ const collectRenames = (schema)=>{
+    const renames = [];
+    const collectFrom = (entries)=>{
+        entries.filter((entry)=>entry.action === 'update' && Array.isArray(entry.renames)).forEach((entry)=>{
+            // Only the last hop onto a name produces the field that carries the
+            // final definition: in `a -> b, b -> c, x -> b` the first `b` is `a`'s
+            // intermediate name and the final `b` is `x`'s field.
+            const lastHopByNewName = new Map();
+            entry.renames.forEach((hop, index)=>{
+                if (hop.newName) {
+                    lastHopByNewName.set(hop.newName, index);
+                }
+            });
+            entry.renames.forEach((hop, index)=>{
+                if (hop.oldName && hop.newName && hop.oldName !== hop.newName) {
+                    // The definition the field ends up with in this save, so the builder
+                    // can refuse hops that also change the field's storage (type,
+                    // relation target, component…). Intermediate hops of a chain get no
+                    // definition and are checked when the chain completes.
+                    const newAttribute = lastHopByNewName.get(hop.newName) === index ? entry.attributes?.find((attribute)=>attribute.action !== 'delete' && attribute.name === hop.newName)?.properties : undefined;
+                    renames.push({
+                        uid: entry.uid,
+                        oldName: hop.oldName,
+                        newName: hop.newName,
+                        newAttribute
+                    });
+                }
+            });
+        });
+    };
+    collectFrom(schema.contentTypes);
+    collectFrom(schema.components);
+    return renames;
+};
+/**
+ * Drops renames whose final name is not an attribute after this save (it was
+ * deleted in the same save), so no store is pointed at a field that is gone.
+ */ const keepSavedAttributes = (schema, mapping)=>{
+    const entries = [
+        ...schema.contentTypes,
+        ...schema.components
+    ];
+    const result = {};
+    for (const [uid, renames] of Object.entries(mapping)){
+        const entry = entries.find((candidate)=>candidate.uid === uid);
+        const saved = new Set((entry?.attributes ?? []).filter((attribute)=>attribute.action !== 'delete' && attribute.name).map((attribute)=>attribute.name));
+        for (const [origin, final] of Object.entries(renames)){
+            if (saved.has(final)) {
+                var _result, _uid;
+                (_result = result)[_uid = uid] ?? (_result[_uid] = {});
+                result[uid][origin] = final;
+            }
+        }
+    }
+    return result;
+};
+const describeUnsupportedReason = (reason)=>{
+    switch(reason){
+        case 'type-changed':
+            return 'the field type, relation or component also changed';
+        case 'unsupported-type':
+            return 'the field type cannot be migrated (e.g. polymorphic relation)';
+        case 'attribute-not-found':
+            return 'the field is not in the current schema';
+        case 'target-occupied':
+            return 'the target field still exists in the current schema';
+        case 'model-not-found':
+        default:
+            return 'the type is not in the current schema';
+    }
+};
+/**
+ * Generates a single data-preserving rename migration for the accepted renames
+ * in this save. Must run before the server reloads, while `strapi.db.metadata`
+ * still reflects the old (pre-rename) schema. Resolves to the written file's
+ * path (so a failed save can remove it), or `null` when nothing was written.
+ */ const generateRenameMigrations = async (schema)=>{
+    // In prompt modes the admin strips refused renames before sending the payload.
+    if (getAttributeRenameMigrationMode() === 'never') {
+        return null;
+    }
+    const renames = collectRenames(schema);
+    if (renames.length === 0) {
+        return null;
+    }
+    const migrationBuilder = index.createMigrationBuilder({
+        strapi
+    });
+    for (const { uid, oldName, newName, newAttribute } of renames){
+        migrationBuilder.addRenameAttribute(uid, {
+            oldName,
+            newName,
+            newAttribute
+        });
+    }
+    const attributeRenames = keepSavedAttributes(schema, migrationBuilder.attributeRenamesMapping());
+    if (Object.keys(attributeRenames).length > 0) {
+        migrationBuilder.addAttributeRenames(attributeRenames);
+    }
+    const unsupported = migrationBuilder.getUnsupported();
+    if (unsupported.length > 0) {
+        const fields = unsupported.map((u)=>`${u.uid}.${u.oldName} (${describeUnsupportedReason(u.reason)})`).join(', ');
+        strapi.log.warn(`[content-type-builder] Could not generate a rename migration for ${unsupported.length} field(s): ${fields}. Data in these fields may not be preserved.`);
+    }
+    if (migrationBuilder.hasChanges()) {
+        return migrationBuilder.writeFiles();
+    }
+    return null;
+};
+/**
+ * Renames a single attribute on a content-type or component and generates the
+ * data-preserving migration in one step. Used by the `strapi rename:field` CLI
+ * command so scripted / non-UI workflows get the same behaviour as the admin.
+ *
+ * It reuses the regular `updateSchema` path (and therefore the same rename
+ * resolver via `generateRenameMigrations`), so the migration is resolved against
+ * the pre-reload `strapi.db.metadata` exactly like the admin save. The caller is
+ * responsible for not reloading before this resolves (the CLI simply exits).
+ *
+ * Unlike the admin, there is no one to confirm a data-losing rename, so it
+ * refuses before touching the schema when the rename cannot be migrated.
+ */ const renameAttribute = async (uid, oldName, newName)=>{
+    const { ApplicationError } = utils.errors;
+    if (!oldName || !newName) {
+        throw new ApplicationError('Both an old and a new attribute name are required');
+    }
+    if (oldName === newName) {
+        throw new ApplicationError(`Cannot rename "${oldName}" to itself`);
+    }
+    if (getAttributeRenameMigrationMode() === 'never') {
+        throw new ApplicationError('Rename migrations are disabled (`renameMigrations.attributes: never`); rename the field in the Content-Type Builder instead');
+    }
+    const contentType = strapi.contentTypes[uid];
+    const component = strapi.components[uid];
+    const model = contentType ?? component;
+    if (!model) {
+        throw new ApplicationError(`No content-type or component found for uid "${uid}"`);
+    }
+    if (!model.attributes?.[oldName]) {
+        throw new ApplicationError(`Attribute "${oldName}" does not exist on "${uid}"`);
+    }
+    if (model.attributes?.[newName]) {
+        throw new ApplicationError(`Attribute "${newName}" already exists on "${uid}"`);
+    }
+    // Reuse the formatted, CTB-visible attributes (same shape the admin sends) so
+    // the schema edit matches an admin save and the renamed key is the only change.
+    const formattedSchema = await getSchema();
+    const isComponent = Boolean(component);
+    const entry = isComponent ? formattedSchema.components[uid] : formattedSchema.contentTypes[uid];
+    // Custom fields are exposed with their underlying type; the admin sends them
+    // back as `customField` so the schema file keeps them as custom fields.
+    const toPayloadProperties = (properties)=>properties.customField ? {
+            ...properties,
+            type: 'customField'
+        } : properties;
+    const attributes = entry.attributes.map(({ name, ...properties })=>({
+            action: 'update',
+            name: name === oldName ? newName : name,
+            properties: toPayloadProperties(properties)
+        }));
+    // Dry run: the field keeps its definition, so only the rename itself can be
+    // refused (system attribute, unsupported relation, occupied target…).
+    const { name: _name, ...oldProperties } = entry.attributes.find((attribute)=>attribute.name === oldName) ?? {
+        name: oldName
+    };
+    const probe = index.createMigrationBuilder({
+        strapi
+    });
+    probe.addRenameAttribute(uid, {
+        oldName,
+        newName,
+        newAttribute: toPayloadProperties(oldProperties)
+    });
+    const refused = probe.getUnsupported();
+    if (refused.length > 0) {
+        throw new ApplicationError(`Cannot rename "${oldName}" on "${uid}" without losing its data: ${refused.map(({ reason })=>describeUnsupportedReason(reason)).join(', ')}`);
+    }
+    const renames = [
+        {
+            oldName,
+            newName
+        }
+    ];
+    const payload = isComponent ? {
+        contentTypes: [],
+        components: [
+            {
+                action: 'update',
+                uid,
+                category: model.category,
+                displayName: model.info?.displayName,
+                icon: model.info?.icon,
+                description: model.info?.description,
+                pluginOptions: model.pluginOptions,
+                renames,
+                attributes
+            }
+        ]
+    } : {
+        contentTypes: [
+            {
+                action: 'update',
+                uid,
+                kind: model.kind,
+                displayName: model.info?.displayName,
+                description: model.info?.description,
+                draftAndPublish: Boolean(model.options?.draftAndPublish),
+                options: model.options,
+                pluginOptions: model.pluginOptions,
+                renames,
+                attributes
+            }
+        ],
+        components: []
+    };
+    // Same checks as an admin save (name rules, reserved names, snake-case
+    // uniqueness: `fooBar` next to an existing `foo_bar` would share a column).
+    const { data } = await schema.validateUpdateSchema({
+        data: payload
+    });
+    await updateSchema(data);
+};
 const formatAttributes = (model)=>{
     const { getVisibleAttributes } = utils.contentTypes;
     // only get attributes that can be seen in the CTB
@@ -74,7 +360,7 @@ const formatAttribute = (attribute)=>{
     return attribute;
 };
 const getSchema = async ()=>{
-    const contentTypes$1 = fp.mapValues((contentType)=>{
+    const contentTypes$1 = _.mapValues(strapi.contentTypes, (contentType)=>{
         const { uid, options, globalId, pluginOptions, kind, modelName, plugin, collectionName, info, modelType } = contentType;
         return {
             uid,
@@ -91,8 +377,8 @@ const getSchema = async ()=>{
             visible: contentTypes.isContentTypeVisible(contentType),
             restrictRelationsTo: contentTypes.getRestrictRelationsTo(contentType)
         };
-    }, strapi.contentTypes);
-    const components = fp.mapValues((component)=>{
+    });
+    const components = _.mapValues(strapi.components, (component)=>{
         const { uid, globalId, modelName, collectionName, info, category, modelType } = component;
         return {
             uid,
@@ -104,18 +390,23 @@ const getSchema = async ()=>{
             info,
             attributes: formatAttributes(component)
         };
-    }, strapi.components);
+    });
     const coreContentStructure = strapi.get('content-structure');
     const contentStructure = await coreContentStructure.getCleanedFile();
     return {
         contentStructure,
         contentTypes: contentTypes$1,
-        components
+        components,
+        settings: {
+            renameMigrations: {
+                attributes: getAttributeRenameMigrationMode()
+            }
+        }
     };
 };
 const updateSchema = async (schema)=>{
-    const builder = index();
-    const apiHandler = index$1.getService('api-handler');
+    const builder = index$1();
+    const apiHandler = index$2.getService('api-handler');
     const { components, contentTypes: contentTypes$1, contentStructure } = schema;
     // Reject protected/plugin deletes before builders, API backups, or folder reconciliation can
     // mutate anything. This is the server-side invariant for crafted update requests.
@@ -123,11 +414,13 @@ const updateSchema = async (schema)=>{
     // pre-process data
     removeEmptyDefaultsOnUpdates(schema);
     removeDeletedUIDTargetFieldsOnUpdates(schema);
+    renameConditionVarsOnUpdates(schema);
     const upsertedUids = new Map();
     const deletedUids = new Set();
     const generatedApiNames = [];
     const backedUpApiUids = [];
     let schemaAlreadyRolledBack = false;
+    let migrationFilePath = null;
     const APIsToDelete = contentTypes$1.filter((contentType)=>contentType.action === 'delete').map((contentType)=>contentType.uid);
     try {
         for (const contentType of contentTypes$1){
@@ -142,7 +435,7 @@ const updateSchema = async (schema)=>{
             }
         }
         // Validate folder references before anything is written. This will throw if invalid.
-        index$1.getService('content-structure').validateFromUpdate({
+        index$2.getService('content-structure').validateFromUpdate({
             incomingStructure: contentStructure,
             upsertedUids,
             deletedUids
@@ -175,7 +468,7 @@ const updateSchema = async (schema)=>{
                 if (!contentType.plugin) {
                     // Track before generation because a generator failure can leave a partial skeleton.
                     generatedApiNames.push(contentType.singularName);
-                    await index$1.getService('content-types').generateAPI({
+                    await index$2.getService('content-types').generateAPI({
                         displayName: contentType.displayName,
                         singularName: contentType.singularName,
                         pluralName: contentType.pluralName,
@@ -187,7 +480,6 @@ const updateSchema = async (schema)=>{
                 builder.editContentType({
                     ...contentType,
                     attributes: contentType.attributes.reduce((acc, attr)=>{
-                        // NOTE: handle renaming migrations here by comparing attr name & attr.properties.name
                         if (attr.action === 'delete') {
                             return acc;
                         }
@@ -232,6 +524,9 @@ const updateSchema = async (schema)=>{
         // Components target existing components
         // Nested components target existing components
         // Dynamic zones target existing components
+        // Generate rename migrations before reloading, while strapi.db.metadata still
+        // reflects the pre-rename schema (the controller triggers the reload after this).
+        migrationFilePath = await generateRenameMigrations(schema);
         const schemaFilesWritten = await builder.writeFiles();
         if (!schemaFilesWritten) {
             schemaAlreadyRolledBack = true;
@@ -243,7 +538,7 @@ const updateSchema = async (schema)=>{
             });
         }
         // Commit the single folder file last. Every preceding filesystem mutation can be restored.
-        await index$1.getService('content-structure').commitFromUpdate({
+        await index$2.getService('content-structure').commitFromUpdate({
             incomingStructure: contentStructure,
             deletedUids
         });
@@ -253,7 +548,8 @@ const updateSchema = async (schema)=>{
             apiHandler,
             backedUpApiUids,
             generatedApiNames,
-            schemaAlreadyRolledBack
+            schemaAlreadyRolledBack,
+            migrationFilePath
         });
         throw error;
     }
@@ -303,5 +599,6 @@ const updateSchema = async (schema)=>{
 
 exports.formatAttribute = formatAttribute;
 exports.getSchema = getSchema;
+exports.renameAttribute = renameAttribute;
 exports.updateSchema = updateSchema;
 //# sourceMappingURL=schema.js.map