@strapi/content-type-builder 5.56.0 → 5.57.0

package/dist/admin/components/FormModal/utils/getRenameStorageChange.mjs

@@ -0,0 +1,70 @@
+import { isStorageCompatibleRename } from '../../DataManager/utils/isStorageCompatibleRename.mjs';
+
+/**
+ * Human label for what defines an attribute's storage: the type, plus the
+ * relation kind/target for relations and the component uid (+ repeatable) for
+ * components, so a warning can say what changed.
+ */ const describeAttributeStorage = (attribute)=>{
+    const type = attribute.type ?? 'unknown';
+    if (type === 'relation') {
+        const details = [
+            attribute.relation,
+            attribute.target ? `to ${attribute.target}` : undefined
+        ].filter(Boolean).join(' ');
+        return details ? `${type} (${details})` : type;
+    }
+    if (type === 'component') {
+        const details = [
+            attribute.component,
+            attribute.repeatable ? 'repeatable' : undefined
+        ].filter(Boolean).join(', ');
+        return details ? `${type} (${details})` : type;
+    }
+    return type;
+};
+/**
+ * Detects an attribute edit that renames an existing field *and* changes its
+ * storage (type, relation kind/target, component uid/repeatable). Such a rename
+ * cannot be replayed as a data-preserving migration, so the field is dropped
+ * and recreated empty — the user should be warned before saving.
+ *
+ * For a relation, renaming the other side (`targetAttribute`) counts as well:
+ * the warning then names that field.
+ *
+ * Returns `null` when there is nothing to warn about: rename migrations are
+ * disabled, the field is brand new (no data yet), no name changed, or the
+ * storage is unchanged.
+ */ const getRenameStorageChange = (initial, modified, mode)=>{
+    if (mode === 'never' || initial.status === 'NEW') {
+        return null;
+    }
+    const isRenamed = (oldName, newName)=>Boolean(oldName) && Boolean(newName) && oldName !== newName;
+    const renamed = [
+        [
+            initial.name,
+            modified.name
+        ],
+        ...initial.type === 'relation' ? [
+            [
+                initial.targetAttribute,
+                modified.targetAttribute
+            ]
+        ] : []
+    ].find(([oldName, newName])=>isRenamed(oldName, newName));
+    if (!renamed) {
+        return null;
+    }
+    const [oldName, newName] = renamed;
+    if (isStorageCompatibleRename(initial, modified)) {
+        return null;
+    }
+    return {
+        oldName,
+        newName,
+        oldType: describeAttributeStorage(initial),
+        newType: describeAttributeStorage(modified)
+    };
+};
+
+export { describeAttributeStorage, getRenameStorageChange };
+//# sourceMappingURL=getRenameStorageChange.mjs.map

package/dist/admin/components/FormModal/utils/getRenameStorageChange.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRenameStorageChange.mjs","sources":["../../../../../admin/src/components/FormModal/utils/getRenameStorageChange.ts"],"sourcesContent":["import { isStorageCompatibleRename } from '../../DataManager/utils/isStorageCompatibleRename';\n\nimport type { AnyAttribute, Status } from '../../../types';\nimport type { AttributeRenameMigrationMode } from '../../DataManager/RenameMigrationModal';\n\n/** The loosely typed attribute data held by the form reducer (`FormModalData`). */\nexport type AttributeFormData = Record<string, unknown> & {\n  name?: string;\n  status?: Status;\n  type?: string;\n  relation?: string;\n  target?: string | null;\n  component?: string;\n  repeatable?: boolean;\n};\n\nexport interface RenameStorageChange {\n  oldName: string;\n  newName: string;\n  /** Human label of the field's storage before the edit (e.g. `relation (oneToMany to api::tag.tag)`). */\n  oldType: string;\n  /** Human label of the field's storage after the edit. */\n  newType: string;\n}\n\n/**\n * Human label for what defines an attribute's storage: the type, plus the\n * relation kind/target for relations and the component uid (+ repeatable) for\n * components, so a warning can say what changed.\n */\nexport const describeAttributeStorage = (attribute: AttributeFormData): string => {\n  const type = attribute.type ?? 'unknown';\n\n  if (type === 'relation') {\n    const details = [attribute.relation, attribute.target ? `to ${attribute.target}` : undefined]\n      .filter(Boolean)\n      .join(' ');\n    return details ? `${type} (${details})` : type;\n  }\n\n  if (type === 'component') {\n    const details = [attribute.component, attribute.repeatable ? 'repeatable' : undefined]\n      .filter(Boolean)\n      .join(', ');\n    return details ? `${type} (${details})` : type;\n  }\n\n  return type;\n};\n\n/**\n * Detects an attribute edit that renames an existing field *and* changes its\n * storage (type, relation kind/target, component uid/repeatable). Such a rename\n * cannot be replayed as a data-preserving migration, so the field is dropped\n * and recreated empty — the user should be warned before saving.\n *\n * For a relation, renaming the other side (`targetAttribute`) counts as well:\n * the warning then names that field.\n *\n * Returns `null` when there is nothing to warn about: rename migrations are\n * disabled, the field is brand new (no data yet), no name changed, or the\n * storage is unchanged.\n */\nexport const getRenameStorageChange = (\n  initial: AttributeFormData,\n  modified: AttributeFormData,\n  mode: AttributeRenameMigrationMode\n): RenameStorageChange | null => {\n  if (mode === 'never' || initial.status === 'NEW') {\n    return null;\n  }\n\n  const isRenamed = (oldName: unknown, newName: unknown) =>\n    Boolean(oldName) && Boolean(newName) && oldName !== newName;\n\n  const renamed = [\n    [initial.name, modified.name],\n    ...(initial.type === 'relation' ? [[initial.targetAttribute, modified.targetAttribute]] : []),\n  ].find(([oldName, newName]) => isRenamed(oldName, newName));\n  if (!renamed) {\n    return null;\n  }\n\n  const [oldName, newName] = renamed as [string, string];\n\n  if (\n    isStorageCompatibleRename(\n      initial as unknown as AnyAttribute,\n      modified as unknown as AnyAttribute\n    )\n  ) {\n    return null;\n  }\n\n  return {\n    oldName,\n    newName,\n    oldType: describeAttributeStorage(initial),\n    newType: describeAttributeStorage(modified),\n  };\n};\n"],"names":["describeAttributeStorage","attribute","type","details","relation","target","undefined","filter","Boolean","join","component","repeatable","getRenameStorageChange","initial","modified","mode","status","isRenamed","oldName","newName","renamed","name","targetAttribute","find","isStorageCompatibleRename","oldType","newType"],"mappings":";;AAyBA;;;;IAKO,MAAMA,wBAAAA,GAA2B,CAACC,SAAAA,GAAAA;IACvC,MAAMC,IAAAA,GAAOD,SAAAA,CAAUC,IAAI,IAAI,SAAA;AAE/B,IAAA,IAAIA,SAAS,UAAA,EAAY;AACvB,QAAA,MAAMC,OAAAA,GAAU;AAACF,YAAAA,SAAAA,CAAUG,QAAQ;YAAEH,SAAAA,CAAUI,MAAM,GAAG,CAAC,GAAG,EAAEJ,SAAAA,CAAUI,MAAM,EAAE,GAAGC;AAAU,SAAA,CAC1FC,MAAM,CAACC,OAAAA,CAAAA,CACPC,IAAI,CAAC,GAAA,CAAA;QACR,OAAON,OAAAA,GAAU,GAAGD,IAAAA,CAAK,EAAE,EAAEC,OAAAA,CAAQ,CAAC,CAAC,GAAGD,IAAAA;AAC5C,IAAA;AAEA,IAAA,IAAIA,SAAS,WAAA,EAAa;AACxB,QAAA,MAAMC,OAAAA,GAAU;AAACF,YAAAA,SAAAA,CAAUS,SAAS;YAAET,SAAAA,CAAUU,UAAU,GAAG,YAAA,GAAeL;AAAU,SAAA,CACnFC,MAAM,CAACC,OAAAA,CAAAA,CACPC,IAAI,CAAC,IAAA,CAAA;QACR,OAAON,OAAAA,GAAU,GAAGD,IAAAA,CAAK,EAAE,EAAEC,OAAAA,CAAQ,CAAC,CAAC,GAAGD,IAAAA;AAC5C,IAAA;IAEA,OAAOA,IAAAA;AACT;AAEA;;;;;;;;;;;;AAYC,IACM,MAAMU,sBAAAA,GAAyB,CACpCC,SACAC,QAAAA,EACAC,IAAAA,GAAAA;AAEA,IAAA,IAAIA,IAAAA,KAAS,OAAA,IAAWF,OAAAA,CAAQG,MAAM,KAAK,KAAA,EAAO;QAChD,OAAO,IAAA;AACT,IAAA;IAEA,MAAMC,SAAAA,GAAY,CAACC,OAAAA,EAAkBC,OAAAA,GACnCX,QAAQU,OAAAA,CAAAA,IAAYV,OAAAA,CAAQW,YAAYD,OAAAA,KAAYC,OAAAA;AAEtD,IAAA,MAAMC,OAAAA,GAAU;AACd,QAAA;AAACP,YAAAA,OAAAA,CAAQQ,IAAI;AAAEP,YAAAA,QAAAA,CAASO;AAAK,SAAA;WACzBR,OAAAA,CAAQX,IAAI,KAAK,UAAA,GAAa;AAAC,YAAA;AAACW,gBAAAA,OAAAA,CAAQS,eAAe;AAAER,gBAAAA,QAAAA,CAASQ;AAAgB;AAAC,SAAA,GAAG;KAC3F,CAACC,IAAI,CAAC,CAAC,CAACL,SAASC,OAAAA,CAAQ,GAAKF,UAAUC,OAAAA,EAASC,OAAAA,CAAAA,CAAAA;AAClD,IAAA,IAAI,CAACC,OAAAA,EAAS;QACZ,OAAO,IAAA;AACT,IAAA;IAEA,MAAM,CAACF,OAAAA,EAASC,OAAAA,CAAQ,GAAGC,OAAAA;IAE3B,IACEI,yBAAAA,CACEX,SACAC,QAAAA,CAAAA,EAEF;QACA,OAAO,IAAA;AACT,IAAA;IAEA,OAAO;AACLI,QAAAA,OAAAA;AACAC,QAAAA,OAAAA;AACAM,QAAAA,OAAAA,EAASzB,wBAAAA,CAAyBa,OAAAA,CAAAA;AAClCa,QAAAA,OAAAA,EAAS1B,wBAAAA,CAAyBc,QAAAA;AACpC,KAAA;AACF;;;;"}

package/dist/admin/src/components/AIChat/lib/transforms/schemas/toCTB.d.ts

@@ -1,10 +1,11 @@
 import type { ContentType, Component, AnyAttribute } from '../../../../../types';
 import type { Schema } from '../../types/schema';
 /**
- * Transform attributes from Chat format to CTB format
- * Also performs a diff to determine the status of each attribute
+ * Transform attributes from Chat format to CTB format.
+ *
+ * Keep the existing array return type for callers that only need attributes.
  */
-export declare const transformAttributesFromChatToCTB: ({ action, attributes }: Schema, oldSchema?: ContentType | Component) => AnyAttribute[];
+export declare const transformAttributesFromChatToCTB: (schema: Schema, oldSchema?: ContentType | Component) => AnyAttribute[];
 /**
  * Transform schema format
  *  AI chat -> CTB

package/dist/admin/src/components/AIChat/lib/types/schema.d.ts

@@ -1,4 +1,4 @@
-import type { AnyAttribute } from '../../../../types';
+import type { AnyAttribute, RenameHop } from '../../../../types';
 export type SchemaAttribute = Omit<AnyAttribute, 'name' | 'status'> & Record<string, unknown>;
 /**
  * Strapi schema, this is a simplification to make it easier to work with
@@ -17,6 +17,11 @@ export type Schema = {
         draftAndPublish?: boolean;
         localized?: boolean;
     };
+    /**
+     * Optional ordered rename hops for this schema. The AI server does not emit
+     * this today, but the CTB admin transform accepts it for forward compatibility.
+     */
+    renames?: RenameHop[];
     attributes: Record<string, SchemaAttribute>;
     sources?: unknown;
 };

package/dist/admin/src/components/DataManager/DataManagerContext.d.ts

@@ -1,3 +1,4 @@
+import type { AttributeRenameMigrationMode } from './RenameMigrationModal';
 import type { ContentStructure, FolderSelection, SectionKey } from './utils/contentStructure';
 import type { Component, ContentType } from '../../types';
 import type { ComponentWithChildren } from './utils/retrieveComponentsThatHaveComponents';
@@ -15,6 +16,10 @@ export interface DataManagerContextValue {
         forTarget: Struct.ModelType;
         targetUid: Internal.UID.Schema;
         name: string;
+        recordRename?: boolean;
+        declineRename?: boolean;
+        recordTargetRename?: boolean;
+        declineTargetRename?: boolean;
     }) => void;
     moveAttribute: (opts: {
         forTarget: Struct.ModelType;
@@ -32,7 +37,22 @@ export interface DataManagerContextValue {
         forTarget: Struct.ModelType;
         targetUid: Internal.UID.Schema;
         name: string;
-    }) => void;
+        recordRename?: boolean;
+        declineRename?: boolean;
+    }) => void;
+    /**
+     * Resolves the user's consent to preserve data for one rename hop performed
+     * in the attribute form: `true` records the hop, `false` declines it (and the
+     * rest of its chain), `null` means the user cancelled the edit.
+     */
+    confirmAttributeRenameMigration: (rename: {
+        forTarget: Struct.ModelType;
+        uid: Internal.UID.Schema;
+        oldName: string;
+        newName: string;
+    }) => Promise<boolean | null>;
+    /** Effective `renameMigrations.attributes` plugin setting. */
+    attributeRenameMigrationMode: AttributeRenameMigrationMode;
     addCreatedComponentToDynamicZone: (opts: {
         forTarget: Struct.ModelType;
         targetUid: Internal.UID.Schema;
@@ -164,10 +184,16 @@ export interface DataManagerContextValue {
     saveSchema(): Promise<void>;
     isModified: boolean;
     isSaving: boolean;
+    /**
+     * Applies a whole-type change (AI chat). Rename hops declared by the change
+     * go through the same preservation consent as manual renames, so this may
+     * prompt the user. Resolves `false` when the user cancelled and nothing was
+     * applied.
+     */
     applyChange: (opts: {
         action: 'add' | 'update' | 'delete';
         schema: ContentType | Component;
-    }) => void;
+    }) => Promise<boolean>;
     history: {
         undo(): void;
         redo(): void;

package/dist/admin/src/components/DataManager/RenameMigrationModal.d.ts

@@ -0,0 +1,73 @@
+import { type RenameChain, type RenamePair } from './utils/groupRenameChains';
+import type { RenameHop } from '../../types';
+export type AttributeRenameMigrationMode = 'always' | 'never' | 'prompt-after-edit' | 'prompt-before-save';
+export type AttributeRenameDecision = boolean | 'prompt';
+export declare const getAttributeRenameDecision: (mode: AttributeRenameMigrationMode) => AttributeRenameDecision;
+export declare const shouldPromptForRenamesBeforeSave: (mode: AttributeRenameMigrationMode) => boolean;
+/**
+ * One rename *chain* on an existing type, shown as a single row in the
+ * confirmation modal. Consent is given per chain, never per hop: replaying a
+ * partial chain either fails or silently skips hops whose target column still
+ * exists. `key` is the chain id (`${uid}:chain:${firstHopIndex}`) so a decision
+ * maps back to every hop of that chain in the type's ordered `renames` array.
+ */
+export interface PendingRename {
+    key: string;
+    uid: string;
+    typeName: string;
+    /** Net effect of the chain (`old -> new`); the raw hops for a pure swap-back. */
+    pairs: RenamePair[];
+    /** Intermediate names the chain routes through (e.g. `tmp`). */
+    via: string[];
+    /** True when the chain's net effect is empty (fields swapped back) but data still moves. */
+    isSwapBack?: boolean;
+}
+interface RenameMigrationModalProps {
+    renames: PendingRename[];
+    /**
+     * Resolves with the keys of the hops the user chose to preserve (every row
+     * is checked by default), or an empty set for "don't preserve data".
+     */
+    onConfirm: (acceptedKeys: Set<string>) => void;
+    /** Aborts the current edit or save and returns to editing. */
+    onCancel: () => void;
+}
+declare const RenameMigrationModal: ({ renames, onConfirm, onCancel }: RenameMigrationModalProps) => import("react/jsx-runtime").JSX.Element;
+export { RenameMigrationModal };
+type RenameAwareEntry = {
+    action?: string;
+    uid: string;
+    displayName?: string;
+    renames?: RenameHop[];
+};
+/**
+ * Builds the modal row for one chain. A chain whose net effect is empty (the
+ * user renamed fields back to their original names through a swap) still has
+ * to run every hop, so its raw hops are shown instead of an empty row.
+ */
+export declare const toPendingRename: (chain: RenameChain, renames: RenameHop[], { uid, typeName }: {
+    uid: string;
+    typeName: string;
+}) => PendingRename;
+/**
+ * Groups the ordered per-type `renames` arrays in a request payload into
+ * chains for display, one `PendingRename` per chain, preserving order.
+ */
+export declare const collectPendingRenames: (requestData: {
+    contentTypes: RenameAwareEntry[];
+    components: RenameAwareEntry[];
+}) => PendingRename[];
+/**
+ * Keeps only the hops of `renames` that belong to an accepted chain. Filtering
+ * by index preserves the original order, and a chain is always kept or dropped
+ * as a whole, so the result can never be a truncated chain.
+ */
+export declare const filterRenamesByAcceptedChains: (uid: string, renames: RenameHop[], acceptedChainIds: Set<string>) => RenameHop[];
+/**
+ * Mutates the request payload so each type keeps only the rename chains the
+ * user accepted; types left with no accepted hops drop their `renames` entirely.
+ */
+export declare const applyRenameDecisions: (requestData: {
+    contentTypes: RenameAwareEntry[];
+    components: RenameAwareEntry[];
+}, acceptedKeys: Set<string>) => void;

package/dist/admin/src/components/DataManager/reducer.d.ts

@@ -110,13 +110,28 @@ type CreateSchemaPayload = {
     };
     folder?: FolderAssignmentPayload;
 };
-type EditAttributePayload = {
+type RenameConsentPayload = {
+    /** Record the hop so the server preserves data (default). */
+    recordRename?: boolean;
+    /**
+     * The user declined to preserve data for this hop: remember both names so
+     * later hops of the same chain are declined without another prompt.
+     */
+    declineRename?: boolean;
+    /**
+     * Same pair for the other side of a bidirectional relation, when the edit
+     * renames it on the target type.
+     */
+    recordTargetRename?: boolean;
+    declineTargetRename?: boolean;
+};
+type EditAttributePayload = RenameConsentPayload & {
     attributeToSet: AttributeMutation;
     forTarget: Struct.ModelType;
     targetUid: string;
     name: string;
 };
-type EditCustomFieldAttributePayload = {
+type EditCustomFieldAttributePayload = RenameConsentPayload & {
     attributeToSet: AttributeMutation;
     forTarget: Struct.ModelType;
     targetUid: string;

package/dist/admin/src/components/DataManager/utils/cleanData.d.ts

@@ -46,6 +46,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             displayName: string;
             description?: string;
             icon?: string;
@@ -66,6 +67,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             plugin?: string | undefined;
             info?: import("@strapi/types/dist/struct/schema.js").SchemaInfo | undefined;
             status?: import("../../../types").Status | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
         } | {
             attributes: ({
@@ -79,6 +81,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             singularName: string;
             pluralName: string;
             displayName: string;
@@ -101,6 +104,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             plugin?: string | undefined;
             info?: import("@strapi/types/dist/struct/schema.js").SchemaInfo | undefined;
             status?: import("../../../types").Status | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
         } | {
             attributes: ({
@@ -114,6 +118,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             displayName: string;
             description?: string;
             icon?: string;
@@ -138,6 +143,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             visible?: boolean | undefined;
             status?: import("../../../types").Status | undefined;
             restrictRelationsTo?: import("@strapi/types/dist/schema/attribute/index.js").RelationKind.Any[] | null | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
             category: string | undefined;
         } | {
@@ -152,6 +158,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             singularName: string;
             pluralName: string;
             displayName: string;
@@ -178,6 +185,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             visible?: boolean | undefined;
             status?: import("../../../types").Status | undefined;
             restrictRelationsTo?: import("@strapi/types/dist/schema/attribute/index.js").RelationKind.Any[] | null | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
             category: string | undefined;
         })[];
@@ -196,6 +204,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             displayName: string;
             description?: string;
             icon?: string;
@@ -216,6 +225,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             plugin?: string | undefined;
             info?: import("@strapi/types/dist/struct/schema.js").SchemaInfo | undefined;
             status?: import("../../../types").Status | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
         } | {
             attributes: ({
@@ -229,6 +239,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             singularName: string;
             pluralName: string;
             displayName: string;
@@ -251,6 +262,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             plugin?: string | undefined;
             info?: import("@strapi/types/dist/struct/schema.js").SchemaInfo | undefined;
             status?: import("../../../types").Status | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
         } | {
             attributes: ({
@@ -264,6 +276,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             displayName: string;
             description?: string;
             icon?: string;
@@ -288,6 +301,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             visible?: boolean | undefined;
             status?: import("../../../types").Status | undefined;
             restrictRelationsTo?: import("@strapi/types/dist/schema/attribute/index.js").RelationKind.Any[] | null | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
             category: string | undefined;
         } | {
@@ -302,6 +316,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
                     [k: string]: unknown;
                 };
             })[];
+            renames?: import("../../../types").RenameHop[];
             singularName: string;
             pluralName: string;
             displayName: string;
@@ -328,6 +343,7 @@ declare const stateToRequestData: ({ components, contentTypes, contentStructure,
             visible?: boolean | undefined;
             status?: import("../../../types").Status | undefined;
             restrictRelationsTo?: import("@strapi/types/dist/schema/attribute/index.js").RelationKind.Any[] | null | undefined;
+            declinedRenameNames?: import("../../../types").DeclinedRenameNames | undefined;
             action: string;
             category: string | undefined;
         })[];

package/dist/admin/src/components/DataManager/utils/groupRenameChains.d.ts

@@ -0,0 +1,31 @@
+import type { RenameHop } from '../../../types';
+export interface RenamePair {
+    oldName: string;
+    newName: string;
+}
+/**
+ * A group of rename hops on one type that share attribute names, transitively:
+ * `a -> b`, `b -> c` is one chain, so is the swap `a -> tmp`, `b -> a`,
+ * `tmp -> b`, while `a -> b` and `x -> y` are two chains. Consent to preserve
+ * data is given per chain, never per hop, because replaying a partial chain
+ * either fails or silently skips hops whose target column still exists.
+ */
+export interface RenameChain {
+    /** `${uid}:chain:${firstHopIndex}` — stable key for consent decisions. */
+    id: string;
+    /** Indexes into the type's ordered `renames[]`, ascending. */
+    hopIndexes: number[];
+    /** Net effect after replaying the chain's hops, in first-appearance order. */
+    pairs: RenamePair[];
+    /** Names that only ever appear as intermediates (e.g. `tmp`). */
+    via: string[];
+}
+/**
+ * Groups a type's ordered `renames[]` into chains (see `RenameChain`). Chains
+ * are ordered by their first hop; hops inside a chain keep their index order.
+ */
+export declare const groupRenameChains: (uid: string, renames: RenameHop[]) => RenameChain[];
+/**
+ * Maps every hop index of `renames` to the chain it belongs to.
+ */
+export declare const chainByHopIndex: (chains: RenameChain[]) => Map<number, RenameChain>;

package/dist/admin/src/components/DataManager/utils/isStorageCompatibleRename.d.ts

@@ -0,0 +1,10 @@
+import type { AnyAttribute } from '../../../types';
+/**
+ * Whether `newAttribute` keeps the storage of `previousAttribute`, i.e. whether
+ * renaming the underlying database artifact is enough to carry the data over.
+ * A type change (or a relation retargeted or its direction switched, or a
+ * component swapped) must go through the regular drop-and-recreate path:
+ * renaming the column and letting schema sync alter its type in place can fail
+ * at startup on Postgres/MySQL.
+ */
+export declare const isStorageCompatibleRename: (previousAttribute: AnyAttribute, newAttribute: AnyAttribute) => boolean;

package/dist/admin/src/components/DataManager/utils/resolveAfterEditRenameConsent.d.ts

@@ -0,0 +1,24 @@
+import { type AttributeRenameMigrationMode } from '../RenameMigrationModal';
+import type { RenameHop } from '../../../types';
+export type AfterEditRenameConsent = 'accept' | 'decline' | 'prompt';
+/**
+ * Decides whether a single rename hop (`oldName -> newName`) performed in the
+ * attribute form needs the user's consent to preserve data, given the hops
+ * already recorded on the type and the names of chains the user has declined.
+ *
+ * Consent inherits along a chain, so a chain is always accepted or declined as
+ * a whole (replaying a partial chain either fails or silently skips hops):
+ *
+ * 1. A hop that joins an accepted chain — it continues a recorded hop
+ *    (`oldName` was produced by one) or swaps into a name a recorded hop
+ *    vacated (`newName`) — is accepted without a prompt.
+ * 2. A hop that touches a declined name is declined without a prompt.
+ * 3. Otherwise the mode decides; `prompt-after-edit` asks the user.
+ */
+export declare const resolveAfterEditRenameConsent: ({ renames, declinedRenameNames, oldName, newName, mode, }: {
+    renames: RenameHop[];
+    declinedRenameNames: string[];
+    oldName: string;
+    newName: string;
+    mode: AttributeRenameMigrationMode;
+}) => AfterEditRenameConsent;

package/dist/admin/src/components/DataManager/utils/splitChainsByInheritedConsent.d.ts

@@ -0,0 +1,26 @@
+import type { RenameChain } from './groupRenameChains';
+import type { RenameHop } from '../../../types';
+export interface SplitChains {
+    /** Chains that join a chain the user already accepted: kept without a prompt. */
+    keep: RenameChain[];
+    /** Chains touching a name the user already declined: dropped without a prompt. */
+    decline: RenameChain[];
+    /** Chains with no prior decision: the user has to be asked. */
+    prompt: RenameChain[];
+}
+/**
+ * Buckets incoming rename chains (e.g. declared by the AI chat) by the consent
+ * the user already gave for the hops recorded on the type, using the same rules
+ * as the per-edit prompt (see `resolveAfterEditRenameConsent`): a chain that
+ * continues a recorded hop or swaps into a name one vacated is kept, a chain
+ * touching a declined name is declined, anything else needs a prompt.
+ */
+export declare const splitChainsByInheritedConsent: ({ recorded, declinedRenameNames, chains, renames, }: {
+    recorded: RenameHop[];
+    declinedRenameNames: string[];
+    chains: RenameChain[];
+    /** The ordered hops the chains index into. */
+    renames: RenameHop[];
+}) => SplitChains;
+/** Every attribute name a set of chains touches, deduplicated, in hop order. */
+export declare const namesOfChains: (chains: RenameChain[], renames: RenameHop[]) => string[];

package/dist/admin/src/components/FormModal/utils/getRenameStorageChange.d.ts

@@ -0,0 +1,40 @@
+import type { Status } from '../../../types';
+import type { AttributeRenameMigrationMode } from '../../DataManager/RenameMigrationModal';
+/** The loosely typed attribute data held by the form reducer (`FormModalData`). */
+export type AttributeFormData = Record<string, unknown> & {
+    name?: string;
+    status?: Status;
+    type?: string;
+    relation?: string;
+    target?: string | null;
+    component?: string;
+    repeatable?: boolean;
+};
+export interface RenameStorageChange {
+    oldName: string;
+    newName: string;
+    /** Human label of the field's storage before the edit (e.g. `relation (oneToMany to api::tag.tag)`). */
+    oldType: string;
+    /** Human label of the field's storage after the edit. */
+    newType: string;
+}
+/**
+ * Human label for what defines an attribute's storage: the type, plus the
+ * relation kind/target for relations and the component uid (+ repeatable) for
+ * components, so a warning can say what changed.
+ */
+export declare const describeAttributeStorage: (attribute: AttributeFormData) => string;
+/**
+ * Detects an attribute edit that renames an existing field *and* changes its
+ * storage (type, relation kind/target, component uid/repeatable). Such a rename
+ * cannot be replayed as a data-preserving migration, so the field is dropped
+ * and recreated empty — the user should be warned before saving.
+ *
+ * For a relation, renaming the other side (`targetAttribute`) counts as well:
+ * the warning then names that field.
+ *
+ * Returns `null` when there is nothing to warn about: rename migrations are
+ * disabled, the field is brand new (no data yet), no name changed, or the
+ * storage is unchanged.
+ */
+export declare const getRenameStorageChange: (initial: AttributeFormData, modified: AttributeFormData, mode: AttributeRenameMigrationMode) => RenameStorageChange | null;

package/dist/admin/src/types.d.ts

@@ -28,6 +28,18 @@ export type Base = {
     customField?: string;
     conditions?: AttributeConditions;
 };
+/**
+ * A single attribute rename hop, recorded in the exact order the user performed
+ * it so the server can replay it as a data-preserving migration. Because the CTB
+ * forbids duplicate field names at any instant, the recorded sequence is always
+ * collision-free (a swap is expressed through the user's own intermediate name).
+ * Only renames of fields that already exist in the database are tracked — never
+ * brand-new fields. Transient (admin only).
+ */
+export type RenameHop = {
+    oldName: string;
+    newName: string;
+};
 export type Relation = Base & {
     type: 'relation';
     relation: Schema.Attribute.RelationKind.Any;
@@ -48,9 +60,18 @@ export type Media = Base & {
     pluginOptions?: Record<string, unknown>;
 };
 export type AnyAttribute = Base & (Schema.Attribute.BigInteger | Schema.Attribute.Boolean | Schema.Attribute.Blocks | Schema.Attribute.Component<UID.Component, boolean> | Schema.Attribute.DateTime | Schema.Attribute.Date | Schema.Attribute.Decimal | Schema.Attribute.DynamicZone | Schema.Attribute.Email | Schema.Attribute.Enumeration<string[]> | Schema.Attribute.Float | Schema.Attribute.Integer | Schema.Attribute.JSON | Schema.Attribute.Password | Schema.Attribute.RichText | Schema.Attribute.String | Schema.Attribute.Text | Schema.Attribute.Time | Schema.Attribute.Timestamp | Schema.Attribute.UID | Media | Relation);
+/**
+ * Attribute names involved in rename chains the user declined to preserve data
+ * for (`prompt-after-edit` mode). A later hop touching one of these names is
+ * declined without a prompt so a chain is never partially preserved. Transient
+ * (admin only), never sent to the server.
+ */
+export type DeclinedRenameNames = string[];
 export type Component = Omit<Struct.ComponentSchema, 'attributes'> & {
     status: Status;
     attributes: Array<AnyAttribute>;
+    renames?: RenameHop[];
+    declinedRenameNames?: DeclinedRenameNames;
 };
 export type ContentType = Omit<Struct.ContentTypeSchema, 'attributes'> & {
     plugin?: string;
@@ -58,6 +79,8 @@ export type ContentType = Omit<Struct.ContentTypeSchema, 'attributes'> & {
     status: Status;
     restrictRelationsTo: Schema.Attribute.RelationKind.Any[] | null;
     attributes: Array<AnyAttribute>;
+    renames?: RenameHop[];
+    declinedRenameNames?: DeclinedRenameNames;
 };
 export type Components = Record<string, Component>;
 export type ContentTypes = Record<string, ContentType>;

package/dist/admin/translations/en.json.js

@@ -153,6 +153,9 @@ var en = {
     "form.attribute.condition.enum-change-warning-end": " will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning": "The following fields have conditions that depend on this field: {fieldNames}. Renaming it will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning-end": ". Renaming it will break these conditions. Do you want to proceed?",
+    "form.attribute.rename-type-change-warning.title": "Existing data will be lost",
+    "form.attribute.rename-type-change-warning.body": "You are renaming {oldName} to {newName} and changing it from {oldType} to {newType}. Strapi cannot preserve the existing data of this field when both change at once. The field will be recreated empty when you save.",
+    "form.attribute.rename-type-change-warning.confirm": "Continue",
     "form.button.add-components-to-dynamiczone": "Add components to the zone",
     "form.button.add-field": "Add another field",
     "form.button.add-first-field-to-created-component": "Add first field to the component",
@@ -173,6 +176,15 @@ var en = {
     "menu.section.components.name": "Components",
     "menu.section.models.name": "Collection Types",
     "menu.section.single-types.name": "Single Types",
+    "migration.confirmation.title": "Preserve data for renamed fields?",
+    "migration.confirmation.description": "You renamed the fields below. Strapi can generate a migration to preserve existing data by renaming the underlying database columns. Untick a rename to let those fields start empty instead.",
+    "migration.confirmation.field.in": "in {typeName}",
+    "migration.confirmation.field.preserve": "Preserve data of {names} in {typeName}",
+    "migration.confirmation.field.via": "via {names}",
+    "migration.confirmation.field.swap": "Fields swapped back to their original names; data still moves.",
+    "migration.confirmation.cancel": "Cancel",
+    "migration.confirmation.decline": "Don't preserve data",
+    "migration.confirmation.confirm": "Preserve data",
     "nav.action.new-collection-type": "New Collection-Type",
     "nav.action.new-folder": "New folder",
     "nav.action.new-single-type": "New Single-Type",

package/dist/admin/translations/en.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/translations/en.json.mjs

@@ -149,6 +149,9 @@ var en = {
     "form.attribute.condition.enum-change-warning-end": " will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning": "The following fields have conditions that depend on this field: {fieldNames}. Renaming it will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning-end": ". Renaming it will break these conditions. Do you want to proceed?",
+    "form.attribute.rename-type-change-warning.title": "Existing data will be lost",
+    "form.attribute.rename-type-change-warning.body": "You are renaming {oldName} to {newName} and changing it from {oldType} to {newType}. Strapi cannot preserve the existing data of this field when both change at once. The field will be recreated empty when you save.",
+    "form.attribute.rename-type-change-warning.confirm": "Continue",
     "form.button.add-components-to-dynamiczone": "Add components to the zone",
     "form.button.add-field": "Add another field",
     "form.button.add-first-field-to-created-component": "Add first field to the component",
@@ -169,6 +172,15 @@ var en = {
     "menu.section.components.name": "Components",
     "menu.section.models.name": "Collection Types",
     "menu.section.single-types.name": "Single Types",
+    "migration.confirmation.title": "Preserve data for renamed fields?",
+    "migration.confirmation.description": "You renamed the fields below. Strapi can generate a migration to preserve existing data by renaming the underlying database columns. Untick a rename to let those fields start empty instead.",
+    "migration.confirmation.field.in": "in {typeName}",
+    "migration.confirmation.field.preserve": "Preserve data of {names} in {typeName}",
+    "migration.confirmation.field.via": "via {names}",
+    "migration.confirmation.field.swap": "Fields swapped back to their original names; data still moves.",
+    "migration.confirmation.cancel": "Cancel",
+    "migration.confirmation.decline": "Don't preserve data",
+    "migration.confirmation.confirm": "Preserve data",
     "nav.action.new-collection-type": "New Collection-Type",
     "nav.action.new-folder": "New folder",
     "nav.action.new-single-type": "New Single-Type",