@modyo/mcp 0.1.0

package/build/tools/channels/releases/SmartPublish.js

@@ -0,0 +1,681 @@
+import { NavigationRepository } from "../../../repositories/channels/navigation/NavigationRepository.js";
+import { PagesRepository } from "../../../repositories/channels/pages/PagesRepository.js";
+import { ReleasesRepository } from "../../../repositories/channels/releases/ReleasesRepository.js";
+import { TemplatesRepository } from "../../../repositories/channels/templates/TemplatesRepository.js";
+import { WidgetDefinitionsRepository } from "../../../repositories/channels/WidgetDefinitions/WidgetDefinitionsRepository.js";
+import { ToolBase } from "../../../shared/index.js";
+import { z } from "zod";
+const paramsSchema = z.object({
+    siteId: z
+        .number()
+        .min(1)
+        .describe("Site ID where the release will be created"),
+    publish_all: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Publish all available elements (default: true)"),
+    element_types: z
+        .array(z.enum([
+        "template",
+        "page",
+        "widgetDefinition",
+        "menu",
+    ]))
+        .optional()
+        .describe("Specific element types to publish (if not publishing all)"),
+    element_names: z
+        .array(z.string())
+        .optional()
+        .describe("Specific element names to publish (partial match)"),
+    dry_run: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Preview what would be published without actually publishing"),
+    dependency_order: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Publish in dependency order: 1) templates, 2) widgets, 3) pages/menus"),
+    continue_on_error: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Continue with remaining phases if one fails (only for dependency_order mode)"),
+});
+class SmartPublishTool extends ToolBase {
+    config = {
+        name: "channels-publish",
+        description: `One-step publishing with dry-run and dependency ordering. IDs change after publishing; UUIDs remain stable.
+📚 modyo://docs/tools/channels-publish`,
+        annotations: {
+            title: "Publish Changes",
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: true,
+        },
+        isPublic: false,
+    };
+    getParamsSchema() {
+        return paramsSchema;
+    }
+    /**
+     * Analyzes dependencies between elements
+     */
+    analyzeDependencies(elements) {
+        const analysis = [];
+        const phases = new Map();
+        const templates = elements.template || [];
+        const widgets = elements.widgetDefinition || [];
+        const pages = elements.page || [];
+        const menus = elements.menu || [];
+        // Phase 1: Templates (no dependencies)
+        phases.set(1, templates);
+        // Phase 2: Widgets (depend on templates)
+        phases.set(2, widgets);
+        // Phase 3: Pages and Menus (depend on widgets and templates)
+        phases.set(3, [
+            ...pages,
+            ...menus,
+        ]);
+        // Build dependency analysis
+        templates.forEach((t) => {
+            analysis.push({
+                uuid: t.oid,
+                name: t.title,
+                type: "template",
+                dependsOn: [],
+                dependedByCount: widgets.length + pages.length,
+            });
+        });
+        widgets.forEach((w) => {
+            analysis.push({
+                uuid: w.oid,
+                name: w.title,
+                type: "widgetDefinition",
+                dependsOn: templates.map((t) => ({
+                    uuid: t.oid,
+                    name: t.title,
+                    type: "template",
+                })),
+                dependedByCount: pages.length,
+            });
+        });
+        pages.forEach((p) => {
+            analysis.push({
+                uuid: p.oid,
+                name: p.title,
+                type: "page",
+                dependsOn: [
+                    ...templates.map((t) => ({
+                        uuid: t.oid,
+                        name: t.title,
+                        type: "template",
+                    })),
+                    ...widgets.map((w) => ({
+                        uuid: w.oid,
+                        name: w.title,
+                        type: "widgetDefinition",
+                    })),
+                ],
+                dependedByCount: 0,
+            });
+        });
+        menus.forEach((m) => {
+            analysis.push({
+                uuid: m.oid,
+                name: m.title,
+                type: "menu",
+                dependsOn: [],
+                dependedByCount: 0,
+            });
+        });
+        return {
+            analysis,
+            phases,
+        };
+    }
+    /**
+     * Builds dry-run response without publishing
+     */
+    buildDryRunResponse(filteredElements, dependencyAnalysis, useDependencyOrder) {
+        const counts = {
+            templates: filteredElements.template?.length || 0,
+            pages: filteredElements.page?.length || 0,
+            widgets: filteredElements.widgetDefinition?.length || 0,
+            menus: filteredElements.menu?.length || 0,
+        };
+        const total = counts.templates + counts.pages + counts.widgets + counts.menus;
+        return {
+            mode: "dry_run",
+            published: counts,
+            updatedElements: {
+                templates: (filteredElements.template || []).map((t) => ({
+                    name: t.title,
+                    uuid: t.oid,
+                    oldId: t.id,
+                    newId: t.id,
+                })),
+                pages: (filteredElements.page || []).map((p) => ({
+                    name: p.title,
+                    uuid: p.oid,
+                    path: "",
+                    oldId: p.id,
+                    newId: p.id,
+                })),
+                widgets: (filteredElements.widgetDefinition || []).map((w) => ({
+                    name: w.title,
+                    uuid: w.oid,
+                    oldId: w.id,
+                    newId: w.id,
+                })),
+                menus: (filteredElements.menu || []).map((m) => ({
+                    name: m.title,
+                    slug: "",
+                    oldId: m.id,
+                    newId: m.id,
+                })),
+            },
+            message: `DRY RUN: Would publish ${total} element${total !== 1 ? "s" : ""}`,
+            dependencies: {
+                analysis: dependencyAnalysis.analysis,
+                order: useDependencyOrder
+                    ? [
+                        {
+                            phase: 1,
+                            name: "templates",
+                            elements: (filteredElements.template || []).map((t) => t.title),
+                        },
+                        {
+                            phase: 2,
+                            name: "widgets",
+                            elements: (filteredElements.widgetDefinition || []).map((w) => w.title),
+                        },
+                        {
+                            phase: 3,
+                            name: "pages_menus",
+                            elements: [
+                                ...(filteredElements.page || []),
+                                ...(filteredElements.menu || []),
+                            ].map((e) => e.title),
+                        },
+                    ]
+                    : [
+                        {
+                            phase: 1,
+                            name: "all",
+                            elements: dependencyAnalysis.analysis.map((a) => a.name),
+                        },
+                    ],
+            },
+        };
+    }
+    /**
+     * Publishes a single phase of elements
+     */
+    async publishPhase(repo, siteId, phaseName, elements) {
+        const phaseNumber = phaseName === "templates" ? 1 : phaseName === "widgets" ? 2 : 3;
+        if (elements.length === 0) {
+            return {
+                phase: phaseNumber,
+                name: phaseName,
+                status: "skipped",
+                publishedCount: 0,
+                elements: [],
+            };
+        }
+        const releaseData = {};
+        if (phaseName === "templates") {
+            releaseData.template = elements.map((e) => ({
+                id: e.id,
+                selected: true,
+            }));
+        }
+        else if (phaseName === "widgets") {
+            releaseData.widgetDefinition = elements.map((e) => ({
+                id: e.id,
+                selected: true,
+            }));
+        }
+        else {
+            releaseData.page = elements
+                .filter((e) => e.type === "page")
+                .map((e) => ({
+                id: e.id,
+                selected: true,
+            }));
+            releaseData.menu = elements
+                .filter((e) => e.type === "menu")
+                .map((e) => ({
+                id: e.id,
+                selected: true,
+            }));
+        }
+        try {
+            await repo.createRelease(siteId, {
+                data: releaseData,
+                scheduled: false,
+            });
+            return {
+                phase: phaseNumber,
+                name: phaseName,
+                status: "success",
+                publishedCount: elements.length,
+                elements: elements.map((e) => ({
+                    name: e.title,
+                    uuid: e.oid,
+                    type: e.type,
+                    oldId: e.id,
+                })),
+            };
+        }
+        catch (error) {
+            return {
+                phase: phaseNumber,
+                name: phaseName,
+                status: "failed",
+                publishedCount: 0,
+                elements: elements.map((e) => ({
+                    name: e.title,
+                    uuid: e.oid,
+                    type: e.type,
+                    oldId: e.id,
+                })),
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async execute(params) {
+        const { siteId, publish_all, element_types, element_names, dry_run, dependency_order, continue_on_error, } = params;
+        const repo = await this.getRepository(ReleasesRepository);
+        this.debug("Getting elements to publish", {
+            siteId,
+            dry_run,
+            dependency_order,
+        });
+        // Step 1: Get elements to publish
+        const elements = await repo.getElementsToPublish(siteId);
+        // Step 2: Filter elements based on criteria
+        const filterByName = (title) => {
+            if (!element_names || element_names.length === 0)
+                return true;
+            return element_names.some((filter) => title.toLowerCase().includes(filter.toLowerCase()));
+        };
+        const shouldIncludeType = (type) => {
+            if (publish_all)
+                return true;
+            if (!element_types || element_types.length === 0)
+                return false;
+            return element_types.includes(type);
+        };
+        // Build filtered elements
+        const filteredElements = {};
+        if (shouldIncludeType("template") && elements.template) {
+            filteredElements.template = elements.template.filter((t) => filterByName(t.title));
+        }
+        if (shouldIncludeType("page") && elements.page) {
+            filteredElements.page = elements.page.filter((p) => filterByName(p.title));
+        }
+        if (shouldIncludeType("widgetDefinition") && elements.widgetDefinition) {
+            filteredElements.widgetDefinition = elements.widgetDefinition.filter((w) => filterByName(w.title));
+        }
+        if (shouldIncludeType("menu") && elements.menu) {
+            filteredElements.menu = elements.menu.filter((m) => filterByName(m.title));
+        }
+        const counts = {
+            templates: filteredElements.template?.length || 0,
+            pages: filteredElements.page?.length || 0,
+            widgets: filteredElements.widgetDefinition?.length || 0,
+            menus: filteredElements.menu?.length || 0,
+        };
+        const totalElements = counts.templates + counts.pages + counts.widgets + counts.menus;
+        // Analyze dependencies
+        const dependencyAnalysis = this.analyzeDependencies(filteredElements);
+        // Handle empty result
+        if (totalElements === 0) {
+            const mode = dry_run
+                ? "dry_run"
+                : dependency_order
+                    ? "ordered"
+                    : "atomic";
+            return this.success({
+                mode,
+                published: counts,
+                updatedElements: {
+                    templates: [],
+                    pages: [],
+                    widgets: [],
+                    menus: [],
+                },
+                message: "No elements found matching the criteria",
+            });
+        }
+        // Handle dry-run mode
+        if (dry_run) {
+            this.debug("Dry-run mode - returning preview", {
+                totalElements,
+            });
+            const response = this.buildDryRunResponse(filteredElements, dependencyAnalysis, dependency_order);
+            return this.success(response);
+        }
+        // Handle dependency-ordered publishing
+        if (dependency_order) {
+            this.debug("Publishing in dependency order", {
+                totalElements,
+            });
+            return this.executeOrderedPublish(repo, siteId, filteredElements, dependencyAnalysis, continue_on_error);
+        }
+        // Default atomic publish (existing behavior)
+        return this.executeAtomicPublish(repo, siteId, filteredElements, counts);
+    }
+    /**
+     * Execute ordered publish in three phases
+     */
+    async executeOrderedPublish(repo, siteId, filteredElements, dependencyAnalysis, continueOnError) {
+        const phases = [];
+        const warnings = [];
+        // Phase 1: Templates
+        const phase1 = await this.publishPhase(repo, siteId, "templates", filteredElements.template || []);
+        phases.push(phase1);
+        if (phase1.status === "failed") {
+            warnings.push(`Phase 1 (templates) failed: ${phase1.error}`);
+            if (!continueOnError) {
+                return this.buildOrderedResponse(phases, warnings, filteredElements, dependencyAnalysis);
+            }
+        }
+        // Phase 2: Widgets
+        const phase2 = await this.publishPhase(repo, siteId, "widgets", filteredElements.widgetDefinition || []);
+        phases.push(phase2);
+        if (phase2.status === "failed") {
+            warnings.push(`Phase 2 (widgets) failed: ${phase2.error}`);
+            if (!continueOnError) {
+                return this.buildOrderedResponse(phases, warnings, filteredElements, dependencyAnalysis);
+            }
+        }
+        // Phase 3: Pages and Menus
+        const phase3Elements = [
+            ...(filteredElements.page || []),
+            ...(filteredElements.menu || []),
+        ];
+        const phase3 = await this.publishPhase(repo, siteId, "pages_menus", phase3Elements);
+        phases.push(phase3);
+        if (phase3.status === "failed") {
+            warnings.push(`Phase 3 (pages/menus) failed: ${phase3.error}`);
+        }
+        return this.buildOrderedResponse(phases, warnings, filteredElements, dependencyAnalysis);
+    }
+    /**
+     * Build response for ordered publish
+     */
+    buildOrderedResponse(phases, warnings, filteredElements, dependencyAnalysis) {
+        const totalPublished = phases.reduce((sum, p) => sum + p.publishedCount, 0);
+        const hasFailure = phases.some((p) => p.status === "failed");
+        const successfulPhases = phases.filter((p) => p.status === "success").length;
+        const counts = {
+            templates: phases.find((p) => p.name === "templates")?.publishedCount || 0,
+            pages: phases
+                .find((p) => p.name === "pages_menus")
+                ?.elements.filter((e) => e.type === "page").length || 0,
+            widgets: phases.find((p) => p.name === "widgets")?.publishedCount || 0,
+            menus: phases
+                .find((p) => p.name === "pages_menus")
+                ?.elements.filter((e) => e.type === "menu").length || 0,
+        };
+        return this.success({
+            mode: "ordered",
+            published: counts,
+            updatedElements: {
+                templates: phases
+                    .find((p) => p.name === "templates")
+                    ?.elements.map((e) => ({
+                    name: e.name,
+                    uuid: e.uuid,
+                    oldId: e.oldId,
+                    newId: e.newId || e.oldId,
+                })) || [],
+                pages: phases
+                    .find((p) => p.name === "pages_menus")
+                    ?.elements.filter((e) => e.type === "page")
+                    .map((e) => ({
+                    name: e.name,
+                    uuid: e.uuid,
+                    path: "",
+                    oldId: e.oldId,
+                    newId: e.newId || e.oldId,
+                })) || [],
+                widgets: phases
+                    .find((p) => p.name === "widgets")
+                    ?.elements.map((e) => ({
+                    name: e.name,
+                    uuid: e.uuid,
+                    oldId: e.oldId,
+                    newId: e.newId || e.oldId,
+                })) || [],
+                menus: phases
+                    .find((p) => p.name === "pages_menus")
+                    ?.elements.filter((e) => e.type === "menu")
+                    .map((e) => ({
+                    name: e.name,
+                    slug: "",
+                    oldId: e.oldId,
+                    newId: e.newId || e.oldId,
+                })) || [],
+            },
+            message: hasFailure
+                ? `Published ${totalPublished} elements with warnings`
+                : `Published ${totalPublished} elements in ${successfulPhases} phases`,
+            phases,
+            dependencies: {
+                analysis: dependencyAnalysis.analysis,
+                order: [
+                    {
+                        phase: 1,
+                        name: "templates",
+                        elements: (filteredElements.template || []).map((t) => t.title),
+                    },
+                    {
+                        phase: 2,
+                        name: "widgets",
+                        elements: (filteredElements.widgetDefinition || []).map((w) => w.title),
+                    },
+                    {
+                        phase: 3,
+                        name: "pages_menus",
+                        elements: [
+                            ...(filteredElements.page || []),
+                            ...(filteredElements.menu || []),
+                        ].map((e) => e.title),
+                    },
+                ],
+            },
+            ...(warnings.length > 0 && {
+                warnings,
+            }),
+        });
+    }
+    /**
+     * Execute atomic publish (original behavior)
+     */
+    async executeAtomicPublish(repo, siteId, filteredElements, counts) {
+        // Build release data
+        const releaseData = {};
+        // Track elements being published (UUID -> old ID mapping)
+        const publishedUUIDs = {
+            templates: new Map(),
+            pages: new Map(),
+            widgets: new Map(),
+            menus: new Map(),
+        };
+        if (filteredElements.template) {
+            releaseData.template = filteredElements.template.map((t) => ({
+                id: t.id,
+                selected: true,
+            }));
+            filteredElements.template.forEach((t) => {
+                publishedUUIDs.templates.set(t.oid, {
+                    oldId: t.id,
+                    title: t.title,
+                });
+            });
+        }
+        if (filteredElements.page) {
+            releaseData.page = filteredElements.page.map((p) => ({
+                id: p.id,
+                selected: true,
+            }));
+            filteredElements.page.forEach((p) => {
+                publishedUUIDs.pages.set(p.oid, {
+                    oldId: p.id,
+                    title: p.title,
+                });
+            });
+        }
+        if (filteredElements.widgetDefinition) {
+            releaseData.widgetDefinition = filteredElements.widgetDefinition.map((w) => ({
+                id: w.id,
+                selected: true,
+            }));
+            filteredElements.widgetDefinition.forEach((w) => {
+                publishedUUIDs.widgets.set(w.oid, {
+                    oldId: w.id,
+                    title: w.title,
+                });
+            });
+        }
+        if (filteredElements.menu) {
+            releaseData.menu = filteredElements.menu.map((m) => ({
+                id: m.id,
+                selected: true,
+            }));
+            filteredElements.menu.forEach((m) => {
+                publishedUUIDs.menus.set(m.oid, {
+                    oldId: m.id,
+                    title: m.title,
+                });
+            });
+        }
+        const totalPublished = counts.templates + counts.pages + counts.widgets + counts.menus;
+        this.debug("Publishing elements (atomic)", {
+            siteId,
+            counts,
+            totalPublished,
+        });
+        // Create release
+        await repo.createRelease(siteId, {
+            data: releaseData,
+            scheduled: false,
+        });
+        // Fetch updated elements to get new IDs
+        const updatedElements = await this.fetchUpdatedElements(siteId, publishedUUIDs);
+        this.logger("Elements published successfully (atomic)", {
+            siteId,
+            counts,
+            totalPublished,
+        });
+        return this.success({
+            mode: "atomic",
+            published: counts,
+            updatedElements,
+            message: `Published ${totalPublished} element${totalPublished !== 1 ? "s" : ""} successfully`,
+        });
+    }
+    /**
+     * Fetch updated element IDs after publishing
+     */
+    async fetchUpdatedElements(siteId, publishedUUIDs) {
+        const updatedElements = {
+            templates: [],
+            pages: [],
+            widgets: [],
+            menus: [],
+        };
+        // Fetch updated templates
+        if (publishedUUIDs.templates.size > 0) {
+            const templatesRepo = await this.getRepository(TemplatesRepository);
+            const templatesData = await templatesRepo.getTemplates(siteId, {
+                per_page: 100,
+            });
+            for (const template of templatesData.templates) {
+                const uuid = template.uuid;
+                if (uuid && publishedUUIDs.templates.has(uuid)) {
+                    const oldData = publishedUUIDs.templates.get(uuid);
+                    if (oldData) {
+                        updatedElements.templates.push({
+                            name: template.name,
+                            uuid: uuid,
+                            oldId: oldData.oldId,
+                            newId: template.id,
+                        });
+                    }
+                }
+            }
+        }
+        // Fetch updated pages
+        if (publishedUUIDs.pages.size > 0) {
+            const pagesRepo = await this.getRepository(PagesRepository);
+            const pagesData = await pagesRepo.getPages(siteId, {
+                per_page: 100,
+            });
+            for (const page of pagesData.layout_pages) {
+                const uuid = page.uuid;
+                if (uuid && publishedUUIDs.pages.has(uuid)) {
+                    const oldData = publishedUUIDs.pages.get(uuid);
+                    if (oldData) {
+                        updatedElements.pages.push({
+                            name: page.name,
+                            uuid: uuid,
+                            path: page.full_path,
+                            oldId: oldData.oldId,
+                            newId: page.id,
+                        });
+                    }
+                }
+            }
+        }
+        // Fetch updated widgets
+        if (publishedUUIDs.widgets.size > 0) {
+            const widgetsRepo = await this.getRepository(WidgetDefinitionsRepository);
+            const widgetsData = await widgetsRepo.getWidgetDefinitions(siteId, {
+                page: 1,
+                per_page: 100,
+            });
+            for (const widget of widgetsData.widget_definitions) {
+                const uuid = widget.uuid;
+                if (uuid && publishedUUIDs.widgets.has(uuid)) {
+                    const oldData = publishedUUIDs.widgets.get(uuid);
+                    if (oldData) {
+                        updatedElements.widgets.push({
+                            name: widget.name,
+                            uuid: uuid,
+                            oldId: oldData.oldId,
+                            newId: widget.id,
+                        });
+                    }
+                }
+            }
+        }
+        // Fetch updated menus
+        if (publishedUUIDs.menus.size > 0) {
+            const navigationRepo = await this.getRepository(NavigationRepository);
+            const menusData = await navigationRepo.getMenus(siteId, undefined);
+            for (const menu of menusData.menus) {
+                const slug = menu.slug;
+                for (const [, oldData] of publishedUUIDs.menus.entries()) {
+                    if (menu.name === oldData.title) {
+                        updatedElements.menus.push({
+                            name: menu.name,
+                            slug: slug,
+                            oldId: oldData.oldId,
+                            newId: menu.id,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        return updatedElements;
+    }
+}
+export const SmartPublish = new SmartPublishTool();
+//# sourceMappingURL=SmartPublish.js.map