convex-cms 0.0.1

package/dist/component/contentTypeMigration.js

@@ -0,0 +1,805 @@
+/**
+ * Content Type Migration Utility
+ *
+ * Provides utilities to safely migrate content when content type schemas change.
+ * Handles field additions, removals, renames, and type changes with data
+ * transformation functions.
+ *
+ * Key features:
+ * - Dry-run mode to preview changes before committing
+ * - Custom transformation functions for type conversions
+ * - Field renaming support
+ * - Default value assignment for new fields
+ * - Version snapshot creation for rollback capability
+ * - Batch processing to respect Convex transaction limits
+ *
+ * @example
+ * ```typescript
+ * // Migrate content when changing a field from text to number
+ * const result = await ctx.runMutation(api.contentTypeMigration.migrateContentType, {
+ *   contentTypeId: typeId,
+ *   migrations: [
+ *     {
+ *       type: "TRANSFORM_FIELD",
+ *       fieldName: "price",
+ *       transformation: "TEXT_TO_NUMBER",
+ *     },
+ *     {
+ *       type: "RENAME_FIELD",
+ *       oldFieldName: "desc",
+ *       newFieldName: "description",
+ *     },
+ *     {
+ *       type: "ADD_FIELD",
+ *       fieldName: "featured",
+ *       defaultValue: false,
+ *     },
+ *   ],
+ *   dryRun: true, // Preview changes first
+ *   migratedBy: currentUserId,
+ * });
+ * ```
+ */
+import { v } from "convex/values";
+import { isDeleted } from "./lib/softDelete.js";
+import { mutation, query } from "./_generated/server.js";
+// =============================================================================
+// Transformation Functions
+// =============================================================================
+/**
+ * Convert a text value to a number.
+ */
+function textToNumber(value) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        // Handle common formats
+        const cleaned = trimmed.replace(/[,$]/g, "");
+        const parsed = parseFloat(cleaned);
+        return isNaN(parsed) ? null : parsed;
+    }
+    return null;
+}
+/**
+ * Convert a number value to text.
+ */
+function numberToText(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    return null;
+}
+/**
+ * Convert a text value to boolean.
+ */
+function textToBoolean(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const lower = value.toLowerCase().trim();
+        if (["true", "yes", "1", "on", "enabled"].includes(lower)) {
+            return true;
+        }
+        if (["false", "no", "0", "off", "disabled", ""].includes(lower)) {
+            return false;
+        }
+        return null;
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    return null;
+}
+/**
+ * Convert a boolean value to text.
+ */
+function booleanToText(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    return null;
+}
+/**
+ * Convert a text value to a date timestamp.
+ */
+function textToDate(value) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const timestamp = Date.parse(value);
+        return isNaN(timestamp) ? null : timestamp;
+    }
+    return null;
+}
+/**
+ * Convert a date timestamp to text (ISO format).
+ */
+function dateToText(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return new Date(value).toISOString();
+    }
+    return null;
+}
+/**
+ * Convert a text value (JSON string) to parsed JSON.
+ */
+function textToJson(value) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    if (typeof value === "object") {
+        return value;
+    }
+    if (typeof value === "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            // If it's not valid JSON, return as-is wrapped in object
+            return { value };
+        }
+    }
+    return { value };
+}
+/**
+ * Convert a JSON value to text (stringified).
+ */
+function jsonToText(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * Convert a single value to an array containing that value.
+ */
+function singleToArray(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [value];
+}
+/**
+ * Convert an array to its first element (or null if empty).
+ */
+function arrayToSingle(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0 ? value[0] : null;
+    }
+    return value;
+}
+/**
+ * Remap select/multiSelect values using a provided mapping.
+ */
+function selectValueRemap(value, valueMap) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        // Handle multiSelect
+        return value.map((v) => {
+            if (typeof v === "string" && v in valueMap) {
+                return valueMap[v];
+            }
+            return v;
+        });
+    }
+    if (typeof value === "string" && value in valueMap) {
+        return valueMap[value];
+    }
+    return value;
+}
+/**
+ * Apply a built-in transformation to a value.
+ */
+function applyTransformation(value, transformation, valueMap) {
+    switch (transformation) {
+        case "TEXT_TO_NUMBER":
+            return textToNumber(value);
+        case "NUMBER_TO_TEXT":
+            return numberToText(value);
+        case "TEXT_TO_BOOLEAN":
+            return textToBoolean(value);
+        case "BOOLEAN_TO_TEXT":
+            return booleanToText(value);
+        case "TEXT_TO_DATE":
+            return textToDate(value);
+        case "DATE_TO_TEXT":
+            return dateToText(value);
+        case "TEXT_TO_JSON":
+            return textToJson(value);
+        case "JSON_TO_TEXT":
+            return jsonToText(value);
+        case "SINGLE_TO_ARRAY":
+            return singleToArray(value);
+        case "ARRAY_TO_SINGLE":
+            return arrayToSingle(value);
+        case "SELECT_VALUE_REMAP":
+            return selectValueRemap(value, valueMap ?? {});
+        default:
+            return value;
+    }
+}
+// =============================================================================
+// Migration Logic
+// =============================================================================
+/**
+ * Apply migration operations to a single entry's data.
+ *
+ * @param data - The current entry data
+ * @param operations - Migration operations to apply
+ * @param dryRun - If true, only compute changes without modifying
+ * @returns Object containing the migrated data and list of changes
+ */
+export function applyMigrations(data, operations) {
+    const migratedData = { ...data };
+    const changes = [];
+    for (const op of operations) {
+        switch (op.type) {
+            case "ADD_FIELD": {
+                if (!op.fieldName)
+                    continue;
+                const fieldName = op.fieldName;
+                // Only add if field doesn't exist or is empty (unless preserveEmpty)
+                const currentValue = migratedData[fieldName];
+                const isEmpty = currentValue === undefined ||
+                    currentValue === null ||
+                    currentValue === "";
+                if (isEmpty && !op.preserveEmpty) {
+                    const newValue = op.defaultValue;
+                    if (newValue !== undefined) {
+                        changes.push({
+                            fieldName,
+                            operation: "ADD_FIELD",
+                            oldValue: currentValue,
+                            newValue,
+                        });
+                        migratedData[fieldName] = newValue;
+                    }
+                }
+                break;
+            }
+            case "REMOVE_FIELD": {
+                if (!op.fieldName)
+                    continue;
+                const fieldName = op.fieldName;
+                if (fieldName in migratedData) {
+                    changes.push({
+                        fieldName,
+                        operation: "REMOVE_FIELD",
+                        oldValue: migratedData[fieldName],
+                        newValue: undefined,
+                    });
+                    delete migratedData[fieldName];
+                }
+                break;
+            }
+            case "RENAME_FIELD": {
+                if (!op.oldFieldName || !op.newFieldName)
+                    continue;
+                const { oldFieldName, newFieldName } = op;
+                if (oldFieldName in migratedData) {
+                    const value = migratedData[oldFieldName];
+                    changes.push({
+                        fieldName: oldFieldName,
+                        operation: "RENAME_FIELD",
+                        oldValue: value,
+                        newValue: value,
+                    });
+                    delete migratedData[oldFieldName];
+                    migratedData[newFieldName] = value;
+                }
+                break;
+            }
+            case "TRANSFORM_FIELD": {
+                if (!op.fieldName)
+                    continue;
+                const fieldName = op.fieldName;
+                if (fieldName in migratedData && op.transformation) {
+                    const oldValue = migratedData[fieldName];
+                    const newValue = applyTransformation(oldValue, op.transformation, op.valueMap);
+                    // Only record change if value actually changed
+                    if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+                        changes.push({
+                            fieldName,
+                            operation: "TRANSFORM_FIELD",
+                            oldValue,
+                            newValue,
+                        });
+                        migratedData[fieldName] = newValue;
+                    }
+                }
+                break;
+            }
+            case "SET_DEFAULT": {
+                if (!op.fieldName)
+                    continue;
+                const fieldName = op.fieldName;
+                const currentValue = migratedData[fieldName];
+                const isEmpty = currentValue === undefined ||
+                    currentValue === null ||
+                    currentValue === "";
+                if (isEmpty && !op.preserveEmpty && op.defaultValue !== undefined) {
+                    changes.push({
+                        fieldName,
+                        operation: "SET_DEFAULT",
+                        oldValue: currentValue,
+                        newValue: op.defaultValue,
+                    });
+                    migratedData[fieldName] = op.defaultValue;
+                }
+                break;
+            }
+        }
+    }
+    return { migratedData, changes };
+}
+// =============================================================================
+// Validators
+// =============================================================================
+/**
+ * Validator for migration operation type.
+ */
+const migrationOperationTypeValidator = v.union(v.literal("ADD_FIELD"), v.literal("REMOVE_FIELD"), v.literal("RENAME_FIELD"), v.literal("TRANSFORM_FIELD"), v.literal("SET_DEFAULT"));
+/**
+ * Validator for built-in transformation types.
+ */
+const builtInTransformationValidator = v.union(v.literal("TEXT_TO_NUMBER"), v.literal("NUMBER_TO_TEXT"), v.literal("TEXT_TO_BOOLEAN"), v.literal("BOOLEAN_TO_TEXT"), v.literal("TEXT_TO_DATE"), v.literal("DATE_TO_TEXT"), v.literal("TEXT_TO_JSON"), v.literal("JSON_TO_TEXT"), v.literal("SINGLE_TO_ARRAY"), v.literal("ARRAY_TO_SINGLE"), v.literal("SELECT_VALUE_REMAP"));
+/**
+ * Validator for a migration operation.
+ */
+export const migrationOperationValidator = v.object({
+    type: migrationOperationTypeValidator,
+    fieldName: v.optional(v.string()),
+    oldFieldName: v.optional(v.string()),
+    newFieldName: v.optional(v.string()),
+    defaultValue: v.optional(v.any()),
+    transformation: v.optional(builtInTransformationValidator),
+    customTransformation: v.optional(v.string()),
+    valueMap: v.optional(v.any()),
+    preserveEmpty: v.optional(v.boolean()),
+});
+/**
+ * Validator for migrate content type arguments.
+ */
+export const migrateContentTypeArgs = v.object({
+    /** Content type ID to migrate */
+    contentTypeId: v.id("contentTypes"),
+    /** Array of migration operations to apply */
+    migrations: v.array(migrationOperationValidator),
+    /** If true, preview changes without applying them */
+    dryRun: v.optional(v.boolean()),
+    /** Create version snapshots before migration (default: true) */
+    createVersionSnapshots: v.optional(v.boolean()),
+    /** Filter entries by status (default: all statuses) */
+    statusFilter: v.optional(v.array(v.union(v.literal("draft"), v.literal("published"), v.literal("archived"), v.literal("scheduled")))),
+    /** Only migrate entries with IDs in this list */
+    entryIds: v.optional(v.array(v.id("contentEntries"))),
+    /** User performing the migration */
+    migratedBy: v.optional(v.string()),
+    /** Description of the migration for version history */
+    changeDescription: v.optional(v.string()),
+});
+/**
+ * Validator for entry migration result.
+ */
+const fieldChangeValidator = v.object({
+    fieldName: v.string(),
+    operation: migrationOperationTypeValidator,
+    oldValue: v.optional(v.any()),
+    newValue: v.optional(v.any()),
+});
+const entryMigrationResultValidator = v.object({
+    entryId: v.id("contentEntries"),
+    slug: v.string(),
+    success: v.boolean(),
+    error: v.optional(v.string()),
+    changes: v.optional(v.array(fieldChangeValidator)),
+});
+/**
+ * Validator for migration result.
+ */
+export const migrationResultValidator = v.object({
+    dryRun: v.boolean(),
+    totalEntries: v.number(),
+    successCount: v.number(),
+    failureCount: v.number(),
+    skippedCount: v.number(),
+    results: v.array(entryMigrationResultValidator),
+    versionSnapshotsCreated: v.number(),
+});
+// =============================================================================
+// Mutations
+// =============================================================================
+/**
+ * Mutation to migrate content entries when a content type schema changes.
+ *
+ * This mutation applies a series of migration operations to all entries
+ * of a given content type. It supports:
+ * - Adding new fields with default values
+ * - Removing fields
+ * - Renaming fields
+ * - Transforming field values (type conversions)
+ * - Setting default values for empty fields
+ *
+ * The mutation can run in dry-run mode to preview changes before applying them.
+ * By default, it creates version snapshots before modifying entries.
+ *
+ * @param contentTypeId - The content type to migrate
+ * @param migrations - Array of migration operations to apply
+ * @param dryRun - If true, preview changes without applying (default: false)
+ * @param createVersionSnapshots - Create version snapshots before migration (default: true)
+ * @param statusFilter - Only migrate entries with these statuses
+ * @param entryIds - Only migrate entries with these IDs
+ * @param migratedBy - User performing the migration
+ * @param changeDescription - Description for version history
+ *
+ * @returns MigrationResult with details of all changes
+ *
+ * @example
+ * ```typescript
+ * // Preview migration
+ * const preview = await ctx.runMutation(api.contentTypeMigration.migrateContentType, {
+ *   contentTypeId: blogPostTypeId,
+ *   migrations: [
+ *     { type: "RENAME_FIELD", oldFieldName: "body", newFieldName: "content" },
+ *     { type: "ADD_FIELD", fieldName: "featured", defaultValue: false },
+ *     { type: "TRANSFORM_FIELD", fieldName: "viewCount", transformation: "TEXT_TO_NUMBER" },
+ *   ],
+ *   dryRun: true,
+ * });
+ *
+ * // Apply migration after reviewing preview
+ * const result = await ctx.runMutation(api.contentTypeMigration.migrateContentType, {
+ *   contentTypeId: blogPostTypeId,
+ *   migrations: [...],
+ *   dryRun: false,
+ *   changeDescription: "Renamed body to content, added featured flag",
+ *   migratedBy: currentUserId,
+ * });
+ * ```
+ */
+export const migrateContentType = mutation({
+    args: migrateContentTypeArgs.fields,
+    returns: migrationResultValidator,
+    handler: async (ctx, args) => {
+        const { contentTypeId, migrations, dryRun = false, createVersionSnapshots = true, statusFilter, entryIds, migratedBy, changeDescription = "Content type migration", } = args;
+        // Validate content type exists
+        const contentType = await ctx.db.get(contentTypeId);
+        if (!contentType) {
+            throw new Error(`Content type not found: ${contentTypeId}`);
+        }
+        if (isDeleted(contentType)) {
+            throw new Error(`Content type has been deleted: ${contentType.name}`);
+        }
+        // Validate migration operations
+        for (const op of migrations) {
+            if (op.type === "RENAME_FIELD" &&
+                (!op.oldFieldName || !op.newFieldName)) {
+                throw new Error("RENAME_FIELD operation requires both oldFieldName and newFieldName");
+            }
+            if ((op.type === "ADD_FIELD" ||
+                op.type === "REMOVE_FIELD" ||
+                op.type === "TRANSFORM_FIELD" ||
+                op.type === "SET_DEFAULT") &&
+                !op.fieldName) {
+                throw new Error(`${op.type} operation requires fieldName`);
+            }
+            if (op.type === "TRANSFORM_FIELD" && !op.transformation) {
+                throw new Error("TRANSFORM_FIELD operation requires transformation type");
+            }
+        }
+        // Build query for entries
+        const entriesQuery = ctx.db
+            .query("contentEntries")
+            .withIndex("by_content_type", (q) => q.eq("contentTypeId", contentTypeId))
+            .filter((q) => q.eq(q.field("deletedAt"), undefined));
+        // Collect all entries
+        const allEntries = await entriesQuery.collect();
+        // Filter by status if specified
+        let entries = allEntries;
+        if (statusFilter && statusFilter.length > 0) {
+            entries = entries.filter((e) => statusFilter.includes(e.status));
+        }
+        // Filter by entry IDs if specified
+        if (entryIds && entryIds.length > 0) {
+            const entryIdSet = new Set(entryIds.map((id) => id.toString()));
+            entries = entries.filter((e) => entryIdSet.has(e._id.toString()));
+        }
+        // Process entries
+        const results = [];
+        let successCount = 0;
+        let failureCount = 0;
+        let skippedCount = 0;
+        let versionSnapshotsCreated = 0;
+        for (const entry of entries) {
+            try {
+                const entryData = entry.data;
+                const { migratedData, changes } = applyMigrations(entryData, migrations);
+                // Skip if no changes
+                if (changes.length === 0) {
+                    results.push({
+                        entryId: entry._id,
+                        slug: entry.slug,
+                        success: true,
+                        changes: [],
+                    });
+                    skippedCount++;
+                    continue;
+                }
+                if (dryRun) {
+                    // In dry run mode, just report what would change
+                    results.push({
+                        entryId: entry._id,
+                        slug: entry.slug,
+                        success: true,
+                        changes,
+                    });
+                    successCount++;
+                }
+                else {
+                    // Create version snapshot before migration
+                    if (createVersionSnapshots) {
+                        await ctx.db.insert("contentVersions", {
+                            entryId: entry._id,
+                            versionNumber: entry.version,
+                            data: entry.data,
+                            slug: entry.slug,
+                            status: entry.status,
+                            changeDescription: `Pre-migration snapshot: ${changeDescription}`,
+                            createdBy: migratedBy,
+                            wasPublished: entry.status === "published",
+                            publishedAt: entry.status === "published"
+                                ? entry.lastPublishedAt
+                                : undefined,
+                        });
+                        versionSnapshotsCreated++;
+                    }
+                    // Apply migration
+                    await ctx.db.patch(entry._id, {
+                        data: migratedData,
+                        version: entry.version + 1,
+                        updatedBy: migratedBy,
+                    });
+                    results.push({
+                        entryId: entry._id,
+                        slug: entry.slug,
+                        success: true,
+                        changes,
+                    });
+                    successCount++;
+                }
+            }
+            catch (error) {
+                results.push({
+                    entryId: entry._id,
+                    slug: entry.slug,
+                    success: false,
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+                failureCount++;
+            }
+        }
+        return {
+            dryRun,
+            totalEntries: entries.length,
+            successCount,
+            failureCount,
+            skippedCount,
+            results,
+            versionSnapshotsCreated,
+        };
+    },
+});
+// =============================================================================
+// Queries
+// =============================================================================
+/**
+ * Query to preview migration without modifying data.
+ *
+ * This is a convenience wrapper that always runs in dry-run mode.
+ * Use this to safely preview what changes would be made.
+ */
+export const previewMigration = query({
+    args: {
+        contentTypeId: v.id("contentTypes"),
+        migrations: v.array(migrationOperationValidator),
+        statusFilter: v.optional(v.array(v.union(v.literal("draft"), v.literal("published"), v.literal("archived"), v.literal("scheduled")))),
+        entryIds: v.optional(v.array(v.id("contentEntries"))),
+        /** Limit number of entries to preview (default: 10) */
+        limit: v.optional(v.number()),
+    },
+    returns: v.object({
+        totalEntries: v.number(),
+        previewedEntries: v.number(),
+        results: v.array(entryMigrationResultValidator),
+        summary: v.object({
+            entriesWithChanges: v.number(),
+            entriesWithoutChanges: v.number(),
+            operationCounts: v.any(),
+        }),
+    }),
+    handler: async (ctx, args) => {
+        const { contentTypeId, migrations, statusFilter, entryIds, limit = 10, } = args;
+        // Validate content type exists
+        const contentType = await ctx.db.get(contentTypeId);
+        if (!contentType) {
+            throw new Error(`Content type not found: ${contentTypeId}`);
+        }
+        // Build query for entries
+        let entries = await ctx.db
+            .query("contentEntries")
+            .withIndex("by_content_type", (q) => q.eq("contentTypeId", contentTypeId))
+            .filter((q) => q.eq(q.field("deletedAt"), undefined))
+            .collect();
+        const totalEntries = entries.length;
+        // Filter by status if specified
+        if (statusFilter && statusFilter.length > 0) {
+            entries = entries.filter((e) => statusFilter.includes(e.status));
+        }
+        // Filter by entry IDs if specified
+        if (entryIds && entryIds.length > 0) {
+            const entryIdSet = new Set(entryIds.map((id) => id.toString()));
+            entries = entries.filter((e) => entryIdSet.has(e._id.toString()));
+        }
+        // Limit entries for preview
+        const previewEntries = entries.slice(0, limit);
+        const results = [];
+        const operationCounts = {};
+        let entriesWithChanges = 0;
+        let entriesWithoutChanges = 0;
+        for (const entry of previewEntries) {
+            const entryData = entry.data;
+            const { changes } = applyMigrations(entryData, migrations);
+            if (changes.length > 0) {
+                entriesWithChanges++;
+                for (const change of changes) {
+                    operationCounts[change.operation] =
+                        (operationCounts[change.operation] || 0) + 1;
+                }
+            }
+            else {
+                entriesWithoutChanges++;
+            }
+            results.push({
+                entryId: entry._id,
+                slug: entry.slug,
+                success: true,
+                changes,
+            });
+        }
+        return {
+            totalEntries,
+            previewedEntries: previewEntries.length,
+            results,
+            summary: {
+                entriesWithChanges,
+                entriesWithoutChanges,
+                operationCounts,
+            },
+        };
+    },
+});
+/**
+ * Query to get available transformation types and their descriptions.
+ */
+export const getTransformationTypes = query({
+    args: {},
+    returns: v.array(v.object({
+        type: v.string(),
+        description: v.string(),
+        fromType: v.string(),
+        toType: v.string(),
+    })),
+    handler: async () => {
+        return [
+            {
+                type: "TEXT_TO_NUMBER",
+                description: "Convert text strings to numbers (handles currency formatting)",
+                fromType: "text",
+                toType: "number",
+            },
+            {
+                type: "NUMBER_TO_TEXT",
+                description: "Convert numbers to text strings",
+                fromType: "number",
+                toType: "text",
+            },
+            {
+                type: "TEXT_TO_BOOLEAN",
+                description: "Convert text to boolean (true/false, yes/no, 1/0, on/off, enabled/disabled)",
+                fromType: "text",
+                toType: "boolean",
+            },
+            {
+                type: "BOOLEAN_TO_TEXT",
+                description: 'Convert boolean to "true" or "false" strings',
+                fromType: "boolean",
+                toType: "text",
+            },
+            {
+                type: "TEXT_TO_DATE",
+                description: "Convert date strings to timestamps (ISO 8601 and common formats)",
+                fromType: "text",
+                toType: "date/datetime",
+            },
+            {
+                type: "DATE_TO_TEXT",
+                description: "Convert timestamps to ISO 8601 date strings",
+                fromType: "date/datetime",
+                toType: "text",
+            },
+            {
+                type: "TEXT_TO_JSON",
+                description: "Parse JSON strings to objects",
+                fromType: "text",
+                toType: "json",
+            },
+            {
+                type: "JSON_TO_TEXT",
+                description: "Stringify JSON objects to text",
+                fromType: "json",
+                toType: "text",
+            },
+            {
+                type: "SINGLE_TO_ARRAY",
+                description: "Wrap single values in an array (for multiple references)",
+                fromType: "any",
+                toType: "array",
+            },
+            {
+                type: "ARRAY_TO_SINGLE",
+                description: "Extract first element from array (for single references)",
+                fromType: "array",
+                toType: "any",
+            },
+            {
+                type: "SELECT_VALUE_REMAP",
+                description: "Remap select/multiSelect values using a provided mapping",
+                fromType: "select/multiSelect",
+                toType: "select/multiSelect",
+            },
+        ];
+    },
+});
+//# sourceMappingURL=contentTypeMigration.js.map