@modyo/mcp 0.1.0

package/build/tools/content/spaces/Copy.js

@@ -0,0 +1,804 @@
+import { AssetsRepository } from "../../../repositories/content/assets/AssetsRepository.js";
+import { CategoriesRepository } from "../../../repositories/content/categories/CategoriesRepository.js";
+import { EntriesRepository } from "../../../repositories/content/entries/EntriesRepository.js";
+import { SpacesRepository } from "../../../repositories/content/spaces/SpacesRepository.js";
+import { TypesRepository } from "../../../repositories/content/types/TypesRepository.js";
+import { jobManager, processBatch } from "../../../shared/helpers/index.js";
+import { ToolBase } from "../../../shared/index.js";
+import { z } from "zod";
+import { CopyUtils } from "../helpers/CopyUtils.js";
+const paramsSchema = z.object({
+    // Source
+    sourceSpaceId: z
+        .union([
+        z.string(),
+        z.number(),
+    ])
+        .describe("Source space ID, UID, or name"),
+    // Target
+    newName: z
+        .string()
+        .min(2)
+        .max(100)
+        .optional()
+        .describe("Defaults to source name"),
+    newUid: z
+        .string()
+        .regex(/^[a-z0-9_-]+$/)
+        .optional()
+        .describe("Auto-suffixed on conflict"),
+    // Copy options
+    copyTypes: z
+        .boolean()
+        .default(true)
+        .describe("Copy content types (default: true)"),
+    copyCategories: z
+        .boolean()
+        .default(true)
+        .describe("Copy category hierarchy (default: true)"),
+    copyEntries: z
+        .boolean()
+        .default(false)
+        .describe("Copy all entries (default: false)"),
+    copyAssets: z
+        .boolean()
+        .default(false)
+        .describe("Auto-enabled when copyEntries=true"),
+    entryLimit: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Max entries per type (for testing)"),
+    asyncThreshold: z
+        .number()
+        .int()
+        .positive()
+        .default(50)
+        .describe("Async if entries >= threshold (default: 50)"),
+});
+/**
+ * High-level tool for copying entire spaces.
+ *
+ * Features:
+ * - Space cloning
+ * - Auto-suffix UID on conflict
+ * - Category hierarchy preservation
+ * - Type copying with field remapping
+ * - Optional entry and asset copying
+ */
+class SpaceCopyTool extends ToolBase {
+    config = {
+        name: "content-spaces-copy",
+        description: `Clone entire space with types, categories, entries, assets. Auto-suffixes UID on conflict. Large copies run async (check with content-jobs-manage). 📚 modyo://docs/tools/content-spaces-copy`,
+        annotations: {
+            title: "Copy Space",
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: false,
+        },
+        isPublic: false,
+    };
+    getParamsSchema() {
+        return paramsSchema;
+    }
+    async execute(params) {
+        const { sourceSpaceId, newName, newUid, copyTypes, copyCategories, copyEntries, copyAssets, } = params;
+        // Auto-enable asset copying with entries
+        const shouldCopyAssets = copyAssets || copyEntries;
+        // Get repositories
+        const spaceRepo = await this.getRepository(SpacesRepository);
+        // Step 1: Resolve source space
+        this.debug("Resolving source space", {
+            sourceSpaceId,
+        });
+        const sourceSpace = await this.resolveSpace(spaceRepo, sourceSpaceId);
+        this.debug("Source space resolved", {
+            id: sourceSpace.id,
+            uid: sourceSpace.uid,
+            name: sourceSpace.name,
+        });
+        // Step 2: Resolve naming and conflicts
+        const targetName = newName || sourceSpace.name;
+        let targetUid = newUid || sourceSpace.uid;
+        // Check for UID conflicts
+        const existingSpaces = await spaceRepo.getSpaces({});
+        const existingUids = existingSpaces.spaces?.map((s) => s.uid) || [];
+        if (existingUids.includes(targetUid)) {
+            targetUid = CopyUtils.generateUniqueUid(targetUid, existingUids);
+            this.debug("UID conflict resolved", {
+                original: newUid || sourceSpace.uid,
+                resolved: targetUid,
+            });
+        }
+        // Step 3: Create space in target
+        this.debug("Creating space", {
+            targetUid,
+            targetName,
+        });
+        const createdSpace = await spaceRepo.createSpace({
+            name: targetName,
+            uid: targetUid,
+            default_locale: sourceSpace.default_locale,
+        });
+        // Update space with additional settings
+        await spaceRepo.updateSpace(createdSpace.id, {
+            locales: sourceSpace.locales,
+            cors_enabled: sourceSpace.cors_enabled,
+            cors_allow_all: sourceSpace.cors_allow_all,
+            cors_allowed_origins: sourceSpace.cors_allowed_origins,
+        });
+        this.debug("Space created successfully", {
+            targetSpaceId: createdSpace.id,
+            targetUid: createdSpace.uid,
+        });
+        // Initialize counters and mappings
+        const copied = {
+            types: 0,
+            categories: 0,
+            entries: 0,
+            assets: 0,
+        };
+        const mappings = {
+            types: {},
+            categories: {},
+            assets: {},
+        };
+        // Step 4: Copy categories
+        if (copyCategories) {
+            const categoryResult = await this.copyCategories(sourceSpace.id, createdSpace.id);
+            copied.categories = categoryResult.count;
+            mappings.categories = categoryResult.mapping;
+        }
+        // Step 5: Copy types
+        const typeMapping = new Map();
+        if (copyTypes) {
+            const typeResult = await this.copyTypes(sourceSpace.id, createdSpace.id);
+            copied.types = typeResult.count;
+            mappings.types = typeResult.mapping;
+            // Convert to Map for use in entry copying
+            for (const [srcId, tgtId] of Object.entries(typeResult.mapping)) {
+                typeMapping.set(parseInt(srcId, 10), tgtId);
+            }
+        }
+        // Step 6: Copy assets if needed
+        const assetMapping = new Map();
+        if (shouldCopyAssets && copyEntries) {
+            // Assets will be copied during entry copying
+            // Pre-collect all asset IDs first
+            const assetResult = await this.copyAllAssets(sourceSpace.id, createdSpace.id);
+            copied.assets = assetResult.count;
+            for (const [srcId, tgtId] of Object.entries(assetResult.mapping)) {
+                assetMapping.set(parseInt(srcId, 10), tgtId);
+                mappings.assets[parseInt(srcId, 10)] = tgtId;
+            }
+        }
+        // Step 7: Copy entries
+        if (copyEntries && copyTypes) {
+            // Count total entries before deciding async/sync execution
+            const totalEntries = await this.countTotalEntries(sourceSpace.id, Array.from(typeMapping.keys()), params.entryLimit);
+            this.debug(`Total entries to copy: ${totalEntries}, Threshold: ${params.asyncThreshold}`);
+            // Decide async vs sync based on threshold
+            if (totalEntries >= params.asyncThreshold) {
+                this.debug("Taking ASYNC path", {
+                    totalEntries,
+                    threshold: params.asyncThreshold,
+                });
+                // Execute async - create job and return immediately
+                const job = jobManager.createJob("space-copy", {
+                    sourceSpaceId: sourceSpace.id,
+                    targetSpaceId: createdSpace.id,
+                    totalEntries,
+                });
+                this.debug("Created job", {
+                    jobId: job.id,
+                });
+                // Start async execution in background
+                setImmediate(() => {
+                    this.debug("setImmediate callback executing", {
+                        jobId: job.id,
+                    });
+                    this.executeCopyEntriesAsync(job.id, sourceSpace.id, createdSpace.id, typeMapping, assetMapping, new Map(Object.entries(mappings.categories).map(([k, v]) => [
+                        parseInt(k, 10),
+                        v,
+                    ])), params.entryLimit).catch((error) => {
+                        this.debug("Async copy failed", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        jobManager.failJob(job.id, error instanceof Error ? error.message : String(error));
+                    });
+                });
+                this.debug("About to return success response with job ID", {
+                    jobId: job.id,
+                });
+                // Return job ID immediately
+                const response = this.success({
+                    jobId: job.id,
+                    status: "pending",
+                    message: `Async copy job created for ${totalEntries} entries. Check status with job-status tool.`,
+                    recheckIn: 30, // Seconds
+                    source: {
+                        id: sourceSpace.id,
+                        uid: sourceSpace.uid,
+                        name: sourceSpace.name,
+                    },
+                    target: {
+                        id: createdSpace.id,
+                        uid: targetUid,
+                        name: targetName,
+                    },
+                });
+                this.debug("Response created, returning now", {
+                    hasContent: !!response.content,
+                });
+                return response;
+            }
+            else {
+                this.debug("Taking SYNC path", {
+                    totalEntries,
+                    threshold: params.asyncThreshold,
+                });
+                // Execute synchronously for small operations
+                const entryResult = await this.copyEntries(sourceSpace.id, createdSpace.id, typeMapping, assetMapping, new Map(Object.entries(mappings.categories).map(([k, v]) => [
+                    parseInt(k, 10),
+                    v,
+                ])), params.entryLimit);
+                copied.entries = entryResult.count;
+            }
+        }
+        // Build response (only for sync execution)
+        return this.success({
+            source: {
+                id: sourceSpace.id,
+                uid: sourceSpace.uid,
+                name: sourceSpace.name,
+            },
+            target: {
+                id: createdSpace.id,
+                uid: targetUid,
+                name: targetName,
+            },
+            action: "created",
+            copied,
+            mappings,
+        });
+    }
+    /**
+     * Resolve space by ID, UID, or name
+     */
+    async resolveSpace(repository, identifier) {
+        // If numeric, get directly
+        if (typeof identifier === "number") {
+            return repository.getSpace(identifier);
+        }
+        // If string, could be UID or name
+        const spaces = await repository.getSpaces({
+            query: identifier,
+        });
+        let space = spaces.spaces?.find((s) => s.uid === identifier);
+        // Try name match if UID didn't work
+        if (!space) {
+            space = spaces.spaces?.find((s) => s.name === identifier);
+        }
+        // Try numeric parse
+        if (!space && !Number.isNaN(Number(identifier))) {
+            return repository.getSpace(Number(identifier));
+        }
+        if (!space) {
+            throw new Error(`Space not found with identifier: ${identifier}`);
+        }
+        return space;
+    }
+    /**
+     * Convert Content API response format to Admin API format
+     *
+     * Content API returns: { fields: { fieldName: value } }
+     * Admin API expects: field_values: [{ field_id, type, value }]
+     *
+     * @param contentFields - Fields from Content API
+     * @param typeFields - Type field definitions for mapping names to IDs
+     * @returns Admin API formatted field values
+     */
+    convertContentApiToAdminFormat(contentFields, typeFields) {
+        const fieldValues = [];
+        // Create a map of field name to field definition for quick lookup
+        const fieldMap = new Map();
+        for (const field of typeFields) {
+            fieldMap.set(field.name, field);
+        }
+        // Convert each Content API field to Admin API format
+        for (const [fieldName, fieldValue] of Object.entries(contentFields)) {
+            const fieldDef = fieldMap.get(fieldName);
+            if (!fieldDef || fieldDef.id === null) {
+                this.debug(`Skipping field "${fieldName}" - no matching type definition found`);
+                continue;
+            }
+            // Handle locations field - Content API uses {location: {lat, lon}} format
+            if (fieldDef.type === "locations" && Array.isArray(fieldValue)) {
+                const convertedValue = fieldValue.map((loc) => ({
+                    location_street: loc.location_street,
+                    lat: typeof loc.location?.lat === "string"
+                        ? parseFloat(loc.location.lat)
+                        : loc.location?.lat || loc.lat || 0,
+                    lng: typeof loc.location?.lon === "string"
+                        ? parseFloat(loc.location.lon)
+                        : loc.location?.lon || loc.lng || 0,
+                    country: loc.country || "",
+                    administrative_area_level_1: loc.administrative_area_level_1 || "",
+                    administrative_area_level_2: loc.administrative_area_level_2 || "",
+                    administrative_area_level_3: loc.administrative_area_level_3 || "",
+                    administrative_area_level_4: loc.administrative_area_level_4 || "",
+                    administrative_area_level_5: loc.administrative_area_level_5 || "",
+                }));
+                fieldValues.push({
+                    field_id: fieldDef.id,
+                    type: fieldDef.type,
+                    value: convertedValue,
+                });
+            }
+            else {
+                // All other field types - pass value as-is
+                fieldValues.push({
+                    field_id: fieldDef.id,
+                    type: fieldDef.type,
+                    value: fieldValue,
+                    ...(fieldDef.multi
+                        ? {
+                            multi: true,
+                        }
+                        : {}),
+                });
+            }
+        }
+        return fieldValues;
+    }
+    /**
+     * Copy categories from source to target space
+     */
+    async copyCategories(sourceSpaceId, targetSpaceId) {
+        const catRepo = await this.getRepository(CategoriesRepository);
+        // Get all source categories
+        const sourceCategories = await catRepo.getCategories(sourceSpaceId, {
+            page: 1,
+            per_page: 100,
+        });
+        const categories = sourceCategories.categories || [];
+        if (categories.length === 0) {
+            return {
+                count: 0,
+                mapping: {},
+            };
+        }
+        // Build parent mapping (for flattening we need parent_id)
+        // Categories from API don't have parent_id directly, we need to infer from depth and parent field
+        // For simplicity, we'll create them in order of depth (parents first)
+        const sortedCategories = [
+            ...categories,
+        ].sort((a, b) => a.depth - b.depth);
+        const mapping = {};
+        const slugToIdMapping = new Map();
+        let count = 0;
+        for (const category of sortedCategories) {
+            try {
+                // For nested categories, we'd need parent_id - the API returns parent: null
+                // We'll create all as root categories for now (simplified)
+                // TODO: Enhance to handle parent hierarchy properly
+                const created = await catRepo.createCategory(targetSpaceId, {
+                    name: category.name,
+                    slug: category.slug,
+                    // parent_id: would need to be mapped from source
+                });
+                mapping[category.id] = created.id;
+                slugToIdMapping.set(category.slug, created.id);
+                count++;
+                this.debug("Category copied", {
+                    sourceId: category.id,
+                    targetId: created.id,
+                    name: category.name,
+                });
+            }
+            catch (error) {
+                this.debug("Failed to copy category", {
+                    categoryId: category.id,
+                    name: category.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return {
+            count,
+            mapping,
+        };
+    }
+    /**
+     * Copy types from source to target space
+     */
+    async copyTypes(sourceSpaceId, targetSpaceId) {
+        const typeRepo = await this.getRepository(TypesRepository);
+        // Get all source types
+        const sourceTypes = await typeRepo.getTypes(sourceSpaceId, {});
+        const types = sourceTypes.types || [];
+        if (types.length === 0) {
+            return {
+                count: 0,
+                mapping: {},
+            };
+        }
+        const mapping = {};
+        let count = 0;
+        // First pass: create types without content_type references
+        for (const typeInfo of types) {
+            try {
+                // Get full type with fields
+                const fullType = await typeRepo.getType(sourceSpaceId, typeInfo.id);
+                // Strip field IDs
+                const fields = CopyUtils.stripFieldIds(fullType.fields);
+                // Check for existing UID conflicts
+                const existingTypes = await typeRepo.getTypes(targetSpaceId, {});
+                const existingUids = existingTypes.types?.map((t) => t.uid) || [];
+                let targetUid = fullType.uid;
+                if (existingUids.includes(targetUid)) {
+                    targetUid = CopyUtils.generateUniqueUid(targetUid, existingUids);
+                }
+                // Create type
+                const created = await typeRepo.createType(targetSpaceId, {
+                    name: fullType.name,
+                    uid: targetUid,
+                    single: fullType.single,
+                });
+                // Update type with fields
+                if (fields.length > 0) {
+                    await typeRepo.updateType(targetSpaceId, created.id, {
+                        fields: fields,
+                        dependent_entries: fullType.dependent_entries,
+                    });
+                }
+                mapping[typeInfo.id] = created.id;
+                count++;
+                this.debug("Type copied", {
+                    sourceId: typeInfo.id,
+                    targetId: created.id,
+                    name: fullType.name,
+                });
+            }
+            catch (error) {
+                this.debug("Failed to copy type", {
+                    typeId: typeInfo.id,
+                    name: typeInfo.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        // Second pass: update content_type references
+        const typeIdMapping = new Map(Object.entries(mapping).map(([k, v]) => [
+            parseInt(k, 10),
+            v,
+        ]));
+        for (const typeInfo of types) {
+            const targetTypeId = mapping[typeInfo.id];
+            if (!targetTypeId)
+                continue;
+            try {
+                const fullType = await typeRepo.getType(sourceSpaceId, typeInfo.id);
+                const refs = CopyUtils.findContentTypeReferences(fullType.fields);
+                if (refs.length > 0) {
+                    // Remap references and update
+                    let fields = CopyUtils.stripFieldIds(fullType.fields);
+                    fields = CopyUtils.remapContentTypeReferences(fields, typeIdMapping);
+                    await typeRepo.updateType(targetSpaceId, targetTypeId, {
+                        fields: fields,
+                    });
+                    this.debug("Type references updated", {
+                        typeId: targetTypeId,
+                        refs,
+                    });
+                }
+            }
+            catch (error) {
+                this.debug("Failed to update type references", {
+                    typeId: typeInfo.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return {
+            count,
+            mapping,
+        };
+    }
+    /**
+     * Copy all assets from source to target space
+     */
+    async copyAllAssets(sourceSpaceId, targetSpaceId) {
+        const assetRepo = await this.getRepository(AssetsRepository);
+        const mapping = {};
+        let count = 0;
+        let page = 1;
+        let hasMore = true;
+        while (hasMore) {
+            const assets = await assetRepo.getAssets(sourceSpaceId, {
+                page,
+                per_page: 100,
+            });
+            for (const asset of assets.assets || []) {
+                try {
+                    if (!asset.url) {
+                        this.debug("Asset has no URL, skipping", {
+                            assetId: asset.id,
+                        });
+                        continue;
+                    }
+                    const modyoType = this.mapAssetTypeToModyoType(asset.type);
+                    const assetName = asset.data_file_name.replace(/\.[^.]+$/, "") || `asset-${asset.id}`;
+                    const created = await assetRepo.createAsset(targetSpaceId, {
+                        input: asset.url,
+                        modyoType,
+                        name: assetName,
+                    });
+                    // Update metadata
+                    if (asset.title || asset.description || asset.alt_text) {
+                        await assetRepo.updateAssetMetadata(targetSpaceId, created.id, {
+                            title: asset.title,
+                            description: asset.description ?? undefined,
+                            alt_text: asset.alt_text ?? undefined,
+                        });
+                    }
+                    mapping[asset.id] = created.id;
+                    count++;
+                    this.debug("Asset copied", {
+                        sourceId: asset.id,
+                        targetId: created.id,
+                        name: assetName,
+                    });
+                }
+                catch (error) {
+                    this.debug("Failed to copy asset", {
+                        assetId: asset.id,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            hasMore = (assets.assets?.length || 0) === 100;
+            page++;
+        }
+        return {
+            count,
+            mapping,
+        };
+    }
+    /**
+     * Copy entries from source to target space
+     */
+    async copyEntries(sourceSpaceId, targetSpaceId, typeMapping, assetMapping, categoryMapping, entryLimit, jobId) {
+        const entryRepo = await this.getRepository(EntriesRepository);
+        const typeRepo = await this.getRepository(TypesRepository);
+        const spaceRepo = await this.getRepository(SpacesRepository);
+        let count = 0;
+        const entryMapping = new Map();
+        const usedSlugs = new Set();
+        // Get source space data for UID (needed for Content API)
+        const sourceSpaceData = await spaceRepo.getSpace(sourceSpaceId);
+        const sourceSpaceUid = sourceSpaceData.uid;
+        // Process entries by type
+        for (const [sourceTypeId, targetTypeId] of typeMapping) {
+            // Get field mapping for this type
+            const sourceType = await typeRepo.getType(sourceSpaceId, sourceTypeId);
+            const targetType = await typeRepo.getType(targetSpaceId, targetTypeId);
+            const fieldIdMapping = CopyUtils.buildFieldIdMapping(sourceType.fields, targetType.fields);
+            const sourceTypeUid = sourceType.uid;
+            // Collect ALL entries for this type first
+            const allEntries = [];
+            let page = 1;
+            let hasMore = true;
+            while (hasMore) {
+                const entries = await entryRepo.getEntries(sourceSpaceId, {
+                    type_id: sourceTypeId,
+                    page,
+                    per_page: 100,
+                });
+                allEntries.push(...(entries.entries || []));
+                hasMore = (entries.entries?.length || 0) === 100;
+                page++;
+            }
+            // Apply entry limit if specified
+            const entriesToCopy = entryLimit
+                ? allEntries.slice(0, entryLimit)
+                : allEntries;
+            this.debug(`Processing ${entriesToCopy.length} entries for type ${sourceTypeId}${entryLimit ? ` (limited from ${allEntries.length})` : ""}`);
+            // Process entries in batches with retry
+            const results = await processBatch({
+                items: entriesToCopy,
+                batchSize: 10,
+                continueOnError: true,
+                retryOptions: {
+                    maxRetries: 3,
+                    initialDelayMs: 1000,
+                    retryableStatusCodes: [
+                        429,
+                        503,
+                        504,
+                    ],
+                    onRetry: (attempt, error, delay) => {
+                        this.debug(`Retry ${attempt} after ${delay}ms: ${error.message}`);
+                    },
+                },
+                onProgress: (completed, total) => {
+                    // Update job progress for async operations
+                    if (jobId) {
+                        jobManager.updateProgress(jobId, {
+                            current: completed,
+                            total: total,
+                            message: `Copying entries: ${completed}/${total}`,
+                        });
+                    }
+                    if (completed % 10 === 0 || completed === total) {
+                        this.debug(`Progress: ${completed}/${total} entries copied`);
+                    }
+                },
+                operation: async (entry) => {
+                    this.debug(`\n=== Processing entry: "${entry.name}" (ID: ${entry.id}, Published: ${entry.published}) ===`);
+                    // Fetch complete entry with field_values
+                    // For published entries: use Content API (returns complete data with field_values)
+                    // For draft entries: use Admin API
+                    let fullEntry;
+                    if (entry.published && entry.uuid) {
+                        this.debug(`Fetching PUBLISHED entry from Content API`);
+                        try {
+                            const contentApiData = await entryRepo.getPublishedEntry(sourceSpaceUid, sourceTypeUid, entry.uuid);
+                            // Content API returns data in { meta, fields } structure
+                            // Convert to admin format for consistency
+                            fullEntry = {
+                                ...entry,
+                                field_values: this.convertContentApiToAdminFormat(contentApiData.fields, sourceType.fields),
+                            };
+                            this.debug(`Fetched ${fullEntry.field_values?.length || 0} fields from Content API`);
+                        }
+                        catch (error) {
+                            this.debug(`Content API fetch failed, falling back to Admin API: ${error.message}`);
+                            fullEntry = (await entryRepo.getEntry(sourceSpaceId, entry.id));
+                        }
+                    }
+                    else {
+                        this.debug(`Fetching DRAFT entry from Admin API`);
+                        fullEntry = (await entryRepo.getEntry(sourceSpaceId, entry.id));
+                    }
+                    this.debug(`fullEntry has ${fullEntry.field_values?.length || 0} field_values`);
+                    // Generate unique slug
+                    let targetSlug = fullEntry.slug;
+                    if (usedSlugs.has(targetSlug)) {
+                        targetSlug = CopyUtils.generateUniqueUid(targetSlug, Array.from(usedSlugs));
+                    }
+                    usedSlugs.add(targetSlug);
+                    // Create empty entry
+                    const created = await entryRepo.createEntry(targetSpaceId, {
+                        name: fullEntry.name,
+                        slug: targetSlug,
+                        content_type_id: targetTypeId,
+                    });
+                    this.debug(`Created entry with ID: ${created.id}`);
+                    // Process field values from full entry
+                    let fieldValues = fullEntry.field_values || [];
+                    this.debug(`Source field values count: ${fieldValues.length}`);
+                    // Debug: Log ALL source field values to see what we're getting
+                    if (fieldValues.length > 0) {
+                        this.debug(`ALL source field values:\n${JSON.stringify(fieldValues.map((fv) => ({
+                            field_id: fv.field_id,
+                            type: fv.type,
+                        })), null, 2)}`);
+                    }
+                    // Debug: Log original location fields from source
+                    const sourceLocationFields = fieldValues.filter((fv) => fv.type === "locations");
+                    if (sourceLocationFields.length > 0) {
+                        this.debug(`SOURCE location fields for "${fullEntry.name}":\n${JSON.stringify(sourceLocationFields, null, 2)}`);
+                    }
+                    else {
+                        this.debug(`NO location fields found in source field_values for "${fullEntry.name}"`);
+                    }
+                    if (fieldValues.length > 0) {
+                        // Remap field IDs
+                        fieldValues = CopyUtils.remapFieldIds(fieldValues, fieldIdMapping);
+                        // Remap asset and entry references + transform location fields
+                        fieldValues = CopyUtils.remapEntryFieldValues(fieldValues, assetMapping, entryMapping);
+                        // Debug: Log location fields AFTER transformation
+                        const transformedLocationFields = fieldValues.filter((fv) => fv.type === "locations");
+                        if (transformedLocationFields.length > 0) {
+                            this.debug(`TRANSFORMED location fields for "${fullEntry.name}":\n${JSON.stringify(transformedLocationFields, null, 2)}`);
+                        }
+                        // Update entry with field values
+                        await entryRepo.updateEntry(targetSpaceId, created.id, {
+                            field_values: fieldValues,
+                            ...(fullEntry.category_id &&
+                                categoryMapping.has(fullEntry.category_id)
+                                ? {
+                                    category_id: categoryMapping.get(fullEntry.category_id),
+                                }
+                                : {}),
+                        });
+                    }
+                    entryMapping.set(fullEntry.id, created.id);
+                    return created;
+                },
+            });
+            // Count successes and failures
+            const successCount = results.filter((r) => r.status === "success").length;
+            const failCount = results.filter((r) => r.status === "failed").length;
+            count += successCount;
+            this.debug(`Type ${sourceTypeId} complete: ${successCount} succeeded, ${failCount} failed`);
+        }
+        return {
+            count,
+        };
+    }
+    /**
+     * Count total entries across all types
+     */
+    async countTotalEntries(spaceId, typeIds, entryLimit) {
+        const entryRepo = await this.getRepository(EntriesRepository);
+        let totalCount = 0;
+        for (const typeId of typeIds) {
+            // Get total count for this type (first page has meta with total)
+            const entries = await entryRepo.getEntries(spaceId, {
+                type_id: typeId,
+                page: 1,
+                per_page: 1,
+            });
+            const typeCount = entries.meta?.total_entries || 0;
+            totalCount += typeCount;
+        }
+        // Apply entry limit if specified
+        return entryLimit
+            ? Math.min(totalCount, entryLimit * typeIds.length)
+            : totalCount;
+    }
+    /**
+     * Execute entry copying asynchronously with progress updates
+     */
+    async executeCopyEntriesAsync(jobId, sourceSpaceId, targetSpaceId, typeMapping, assetMapping, categoryMapping, entryLimit) {
+        try {
+            // Update job status to processing
+            jobManager.updateStatus(jobId, "processing");
+            // Execute the copy with progress tracking
+            const result = await this.copyEntries(sourceSpaceId, targetSpaceId, typeMapping, assetMapping, categoryMapping, entryLimit, jobId);
+            // Complete the job with result
+            jobManager.completeJob(jobId, {
+                entriesCopied: result.count,
+                message: `Successfully copied ${result.count} entries`,
+            });
+            this.debug("Async copy completed successfully", {
+                jobId,
+                count: result.count,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            jobManager.failJob(jobId, errorMessage);
+            this.debug("Async copy failed", {
+                jobId,
+                error: errorMessage,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Map API asset type to modyoType for creation
+     */
+    mapAssetTypeToModyoType(apiType) {
+        const typeMap = {
+            Image: "picture",
+            image: "picture",
+            picture: "picture",
+            Picture: "picture",
+            Video: "video",
+            video: "video",
+            Audio: "audio",
+            audio: "audio",
+            Document: "file",
+            document: "file",
+            File: "file",
+            file: "file",
+        };
+        return typeMap[apiType] || "file";
+    }
+}
+export const Copy = new SpaceCopyTool();
+//# sourceMappingURL=Copy.js.map