strapi-sitemap-generator 0.1.1

package/dist/server/index.mjs

@@ -0,0 +1,339 @@
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi }) => ({
+  /**
+   * Generate sitemap XML
+   * Public endpoint for serving sitemap.xml
+   */
+  async generateXml(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const xml = await service2.generateXML();
+      ctx.type = "application/xml";
+      ctx.body = xml;
+    } catch (error) {
+      ctx.throw(500, `Failed to generate sitemap: ${error.message}`);
+    }
+  },
+  /**
+   * Get sitemap data as JSON
+   * Admin endpoint for preview
+   */
+  async getSitemapData(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const data = await service2.getSitemapData();
+      ctx.body = data;
+    } catch (error) {
+      ctx.throw(500, `Failed to get sitemap data: ${error.message}`);
+    }
+  },
+  /**
+   * (Removed) Download sitemap.xml - not needed, engines fetch XML via public URL
+   */
+  /**
+   * Get all available content types
+   * Admin endpoint for content type discovery
+   */
+  async getContentTypes(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const contentTypes2 = await service2.discoverContentTypes();
+      ctx.body = { data: contentTypes2 };
+    } catch (error) {
+      ctx.throw(500, `Failed to discover content types: ${error.message}`);
+    }
+  },
+  /**
+   * Get current plugin configuration
+   * Admin endpoint for loading settings
+   */
+  async getConfig(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const config2 = await service2.getConfig();
+      ctx.body = config2;
+    } catch (error) {
+      ctx.throw(500, `Failed to get config: ${error.message}`);
+    }
+  },
+  /**
+   * Update plugin configuration
+   * Admin endpoint for saving settings
+   */
+  async updateConfig(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const config2 = await service2.updateConfig(ctx.request.body);
+      ctx.body = config2;
+    } catch (error) {
+      ctx.throw(500, `Failed to update config: ${error.message}`);
+    }
+  }
+});
+const controllers = {
+  controller
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/sitemap.xml",
+      handler: "controller.generateXml",
+      config: {
+        auth: false,
+        policies: []
+      }
+    }
+  ]
+};
+const adminAPIRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/data",
+      handler: "controller.getSitemapData",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "controller.getContentTypes",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/config",
+      handler: "controller.getConfig",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "PUT",
+      path: "/config",
+      handler: "controller.updateConfig",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const service = ({ strapi }) => ({
+  /**
+   * Discover ALL content types with slug fields
+   */
+  async discoverContentTypes() {
+    const contentTypes2 = [];
+    const allContentTypes = strapi.contentTypes;
+    for (const [uid, contentType] of Object.entries(allContentTypes)) {
+      if (!uid.startsWith("api::")) continue;
+      const schema = contentType;
+      const attributes = schema.attributes || {};
+      const hasSlug = "slug" in attributes;
+      if (hasSlug) {
+        contentTypes2.push({
+          uid,
+          singularName: schema.info?.singularName || uid.split(".").pop(),
+          pluralName: schema.info?.pluralName || uid.split(".").pop(),
+          displayName: schema.info?.displayName || uid,
+          hasPublishedAt: "publishedAt" in attributes
+        });
+      }
+    }
+    return contentTypes2;
+  },
+  /**
+   * Get content type info
+   */
+  async getContentTypeInfo(uid) {
+    const contentType = strapi.contentTypes[uid];
+    const attributes = contentType.attributes || {};
+    return {
+      singularName: contentType.info?.singularName || uid.split(".").pop(),
+      pluralName: contentType.info?.pluralName || uid.split(".").pop(),
+      displayName: contentType.info?.displayName || uid,
+      hasPublishedAt: "publishedAt" in attributes
+    };
+  },
+  /**
+   * Generate sitemap XML from user-selected content types
+   */
+  async generateXML() {
+    const config2 = await this.getConfig();
+    const {
+      baseUrl = "https://example.com",
+      selectedContentTypes = [],
+      customPaths = {},
+      customPriorities = {},
+      customChangefreq = {}
+    } = config2;
+    strapi.log.info(`[Sitemap] Generating sitemap with ${selectedContentTypes.length} selected content types`);
+    strapi.log.info(`[Sitemap] Selected types:`, selectedContentTypes);
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
+    if (selectedContentTypes.length === 0) {
+      strapi.log.warn("[Sitemap] No content types selected for sitemap generation");
+      xml += "</urlset>";
+      return xml;
+    }
+    for (const uid of selectedContentTypes) {
+      try {
+        const contentType = await this.getContentTypeInfo(uid);
+        strapi.log.info(`[Sitemap] Processing content type: ${uid}`);
+        const entries = await strapi.entityService.findMany(uid);
+        strapi.log.info(`[Sitemap] Found ${entries?.length || 0} entries for ${uid}`);
+        if (entries && Array.isArray(entries) && entries.length > 0) {
+          const basePath = customPaths[uid] || `/${contentType.pluralName}`;
+          const priority = customPriorities[uid] || 0.7;
+          const changefreq = customChangefreq[uid] || "monthly";
+          entries.forEach((entry) => {
+            if (entry.slug) {
+              xml += this.generateUrlEntry({
+                loc: `${baseUrl}${basePath}/${entry.slug}`,
+                lastmod: entry.updatedAt ? new Date(entry.updatedAt).toISOString().split("T")[0] : (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+                priority,
+                changefreq
+              });
+            }
+          });
+        }
+      } catch (error) {
+        strapi.log.error(`[Sitemap] Failed to fetch entries for ${uid}:`, error.message);
+        strapi.log.error(`[Sitemap] Error details:`, error);
+      }
+    }
+    xml += "</urlset>";
+    strapi.log.info(`[Sitemap] Sitemap generation complete`);
+    return xml;
+  },
+  generateUrlEntry({ loc, lastmod, priority, changefreq }) {
+    let entry = "  <url>\n";
+    entry += `    <loc>${this.escapeXml(loc)}</loc>
+`;
+    if (lastmod) entry += `    <lastmod>${lastmod}</lastmod>
+`;
+    if (changefreq) entry += `    <changefreq>${changefreq}</changefreq>
+`;
+    if (priority) entry += `    <priority>${priority}</priority>
+`;
+    entry += "  </url>\n";
+    return entry;
+  },
+  escapeXml(unsafe) {
+    return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  },
+  /**
+   * Get structured sitemap data for frontend display
+   */
+  async getSitemapData() {
+    const config2 = await this.getConfig();
+    const {
+      baseUrl = "https://example.com",
+      selectedContentTypes = [],
+      customPaths = {}
+    } = config2;
+    strapi.log.info(`[Sitemap] Getting sitemap data for ${selectedContentTypes.length} content types`);
+    const data = {
+      entries: {},
+      meta: {
+        totalUrls: 0,
+        lastGenerated: (/* @__PURE__ */ new Date()).toISOString(),
+        contentTypes: []
+      }
+    };
+    if (selectedContentTypes.length === 0) {
+      strapi.log.warn("[Sitemap] No content types selected - returning empty sitemap data");
+      return data;
+    }
+    for (const uid of selectedContentTypes) {
+      try {
+        const contentType = await this.getContentTypeInfo(uid);
+        strapi.log.info(`[Sitemap] Fetching data for ${uid}`);
+        const entries = await strapi.entityService.findMany(uid);
+        strapi.log.info(`[Sitemap] Found ${entries?.length || 0} entries for ${uid}`);
+        if (entries && Array.isArray(entries) && entries.length > 0) {
+          const basePath = customPaths[uid] || `/${contentType.pluralName}`;
+          data.entries[uid] = entries.filter((entry) => entry.slug).map((entry) => ({
+            url: `${baseUrl}${basePath}/${entry.slug}`,
+            title: entry.title || entry.name || entry.slug,
+            lastmod: entry.updatedAt
+          }));
+          data.meta.contentTypes.push({
+            uid,
+            displayName: contentType.displayName,
+            count: data.entries[uid].length
+          });
+          data.meta.totalUrls += data.entries[uid].length;
+        }
+      } catch (error) {
+        strapi.log.error(`[Sitemap] Failed to fetch ${uid}:`, error.message);
+        strapi.log.error(`[Sitemap] Error details:`, error);
+      }
+    }
+    strapi.log.info(`[Sitemap] Total URLs in sitemap: ${data.meta.totalUrls}`);
+    return data;
+  },
+  /**
+   * Get plugin configuration
+   */
+  async getConfig() {
+    const pluginStore = strapi.store({ type: "plugin", name: "strapi-sitemap-generator" });
+    const config2 = await pluginStore.get({ key: "config" });
+    return config2 || {
+      baseUrl: "https://example.com",
+      selectedContentTypes: [],
+      customPaths: {},
+      customPriorities: {},
+      customChangefreq: {}
+    };
+  },
+  /**
+   * Update plugin configuration
+   */
+  async updateConfig(newConfig) {
+    const pluginStore = strapi.store({ type: "plugin", name: "strapi-sitemap-generator" });
+    await pluginStore.set({ key: "config", value: newConfig });
+    return newConfig;
+  }
+});
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/types';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    default: {};
+    validator(): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/controllers/controller.d.ts

@@ -0,0 +1,34 @@
+import type { Core } from '@strapi/types';
+declare const controller: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Generate sitemap XML
+     * Public endpoint for serving sitemap.xml
+     */
+    generateXml(ctx: any): Promise<void>;
+    /**
+     * Get sitemap data as JSON
+     * Admin endpoint for preview
+     */
+    getSitemapData(ctx: any): Promise<void>;
+    /**
+     * (Removed) Download sitemap.xml - not needed, engines fetch XML via public URL
+     */
+    /**
+     * Get all available content types
+     * Admin endpoint for content type discovery
+     */
+    getContentTypes(ctx: any): Promise<void>;
+    /**
+     * Get current plugin configuration
+     * Admin endpoint for loading settings
+     */
+    getConfig(ctx: any): Promise<void>;
+    /**
+     * Update plugin configuration
+     * Admin endpoint for saving settings
+     */
+    updateConfig(ctx: any): Promise<void>;
+};
+export default controller;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    controller: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        generateXml(ctx: any): Promise<void>;
+        getSitemapData(ctx: any): Promise<void>;
+        getContentTypes(ctx: any): Promise<void>;
+        getConfig(ctx: any): Promise<void>;
+        updateConfig(ctx: any): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,95 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: {};
+        validator(): void;
+    };
+    controllers: {
+        controller: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            generateXml(ctx: any): Promise<void>;
+            getSitemapData(ctx: any): Promise<void>;
+            getContentTypes(ctx: any): Promise<void>;
+            getConfig(ctx: any): Promise<void>;
+            updateConfig(ctx: any): Promise<void>;
+        };
+    };
+    routes: {
+        'content-api': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    auth: boolean;
+                    policies: never[];
+                };
+            }[];
+        };
+        /**
+         * Plugin server methods
+         */
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+    };
+    services: {
+        service: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            discoverContentTypes(): Promise<{
+                uid: string;
+                singularName: any;
+                pluralName: any;
+                displayName: any;
+                hasPublishedAt: boolean;
+            }[]>;
+            getContentTypeInfo(uid: string): Promise<{
+                singularName: any;
+                pluralName: any;
+                displayName: any;
+                hasPublishedAt: boolean;
+            }>;
+            generateXML(): Promise<string>;
+            generateUrlEntry({ loc, lastmod, priority, changefreq }: {
+                loc: string;
+                lastmod?: string | undefined;
+                priority?: number | undefined;
+                changefreq?: string | undefined;
+            }): string;
+            escapeXml(unsafe: string): string;
+            getSitemapData(): Promise<{
+                entries: Record<string, any[]>;
+                meta: {
+                    totalUrls: number;
+                    lastGenerated: string;
+                    contentTypes: any[];
+                };
+            }>;
+            getConfig(): Promise<any>;
+            updateConfig(newConfig: any): Promise<any>;
+        };
+    };
+    contentTypes: {};
+    policies: {};
+    middlewares: {};
+};
+export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin/index.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api/index.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            auth: boolean;
+            policies: never[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,26 @@
+declare const routes: {
+    'content-api': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                auth: boolean;
+                policies: never[];
+            };
+        }[];
+    };
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+            };
+        }[];
+    };
+};
+export default routes;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,38 @@
+declare const _default: {
+    service: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        discoverContentTypes(): Promise<{
+            uid: string;
+            singularName: any;
+            pluralName: any;
+            displayName: any;
+            hasPublishedAt: boolean;
+        }[]>;
+        getContentTypeInfo(uid: string): Promise<{
+            singularName: any;
+            pluralName: any;
+            displayName: any;
+            hasPublishedAt: boolean;
+        }>;
+        generateXML(): Promise<string>;
+        generateUrlEntry({ loc, lastmod, priority, changefreq }: {
+            loc: string;
+            lastmod?: string | undefined;
+            priority?: number | undefined;
+            changefreq?: string | undefined;
+        }): string;
+        escapeXml(unsafe: string): string;
+        getSitemapData(): Promise<{
+            entries: Record<string, any[]>;
+            meta: {
+                totalUrls: number;
+                lastGenerated: string;
+                contentTypes: any[];
+            };
+        }>;
+        getConfig(): Promise<any>;
+        updateConfig(newConfig: any): Promise<any>;
+    };
+};
+export default _default;

package/dist/server/src/services/service.d.ts

@@ -0,0 +1,55 @@
+import type { Core } from '@strapi/types';
+declare const service: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Discover ALL content types with slug fields
+     */
+    discoverContentTypes(): Promise<{
+        uid: string;
+        singularName: any;
+        pluralName: any;
+        displayName: any;
+        hasPublishedAt: boolean;
+    }[]>;
+    /**
+     * Get content type info
+     */
+    getContentTypeInfo(uid: string): Promise<{
+        singularName: any;
+        pluralName: any;
+        displayName: any;
+        hasPublishedAt: boolean;
+    }>;
+    /**
+     * Generate sitemap XML from user-selected content types
+     */
+    generateXML(): Promise<string>;
+    generateUrlEntry({ loc, lastmod, priority, changefreq }: {
+        loc: string;
+        lastmod?: string;
+        priority?: number;
+        changefreq?: string;
+    }): string;
+    escapeXml(unsafe: string): string;
+    /**
+     * Get structured sitemap data for frontend display
+     */
+    getSitemapData(): Promise<{
+        entries: Record<string, any[]>;
+        meta: {
+            totalUrls: number;
+            lastGenerated: string;
+            contentTypes: any[];
+        };
+    }>;
+    /**
+     * Get plugin configuration
+     */
+    getConfig(): Promise<any>;
+    /**
+     * Update plugin configuration
+     */
+    updateConfig(newConfig: any): Promise<any>;
+};
+export default service;