@webbycrown/strapi-advanced-sitemap 1.0.3

package/dist/server/src/controllers/controller.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-advanced-sitemap';
+
+const getManualSitemapService = () => strapi.plugin(PLUGIN_ID).service('service');
+
+const getRequestOrigin = (ctx) => {
+  if (ctx.origin) {
+    return ctx.origin;
+  }
+
+  const protocol = ctx.request.protocol || 'http';
+  const host =
+    ctx.request.header['x-forwarded-host'] ||
+    ctx.request.header.host ||
+    (ctx.request.hostname ? `${ctx.request.hostname}` : 'localhost');
+
+  return `${protocol}://${host}`;
+};
+
+module.exports = {
+  async getOptions(ctx) {
+    const data = await strapi.entityService.findMany(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-option`);
+    const single = Array.isArray(data) ? data[0] : data;
+    ctx.body = single || {};
+  },
+
+  async putOptions(ctx) {
+    const body = ctx.request.body || {};
+    const data = await strapi.entityService.findMany(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-option`);
+    const single = Array.isArray(data) ? data[0] : data;
+    if (single && single.id) {
+      await strapi.entityService.update(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-option`, single.id, { data: body });
+    } else {
+      await strapi.entityService.create(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-option`, { data: body });
+    }
+    ctx.body = { ok: true };
+  },
+
+  async getManualSitemaps(ctx) {
+    const sitemaps = await getManualSitemapService().getManualSitemaps();
+    ctx.body = { sitemaps };
+  },
+
+  async putManualSitemaps(ctx) {
+    const payload = ctx.request.body || {};
+    const { sitemaps } = payload;
+
+    if (!Array.isArray(sitemaps)) {
+      ctx.throw(400, 'Invalid payload. Expected "sitemaps" to be an array.');
+    }
+
+    await getManualSitemapService().setManualSitemaps(sitemaps);
+
+    ctx.body = { ok: true };
+  },
+
+  async serveRootSitemap(ctx) {
+    const service = getManualSitemapService();
+    const [manualSitemaps, collectionConfigs, configuredBaseUrl] = await Promise.all([
+      service.getManualSitemaps(),
+      service.getCollectionConfigs(),
+      service.getConfiguredBaseUrl(),
+    ]);
+
+    const origin = getRequestOrigin(ctx);
+    const apiBaseUrl = `${origin}/api/${PLUGIN_ID}`;
+    const publicBaseUrl = service.resolveBaseUrl(configuredBaseUrl, origin);
+    const xml = service.buildRootSitemap(manualSitemaps, collectionConfigs, {
+      apiBaseUrl,
+      publicBaseUrl,
+    });
+
+    ctx.set('Content-Type', 'application/xml; charset=utf-8');
+    ctx.set('Cache-Control', 'no-store');
+    ctx.body = xml;
+  },
+
+  async serveManualSitemapIndex(ctx) {
+    const service = getManualSitemapService();
+    const [sitemaps, configuredBaseUrl] = await Promise.all([
+      service.getManualSitemaps(),
+      service.getConfiguredBaseUrl(),
+    ]);
+    const origin = getRequestOrigin(ctx);
+    const publicBaseUrl = service.resolveBaseUrl(configuredBaseUrl, origin);
+    const xml = service.buildManualSitemapIndex(sitemaps, publicBaseUrl);
+
+    ctx.set('Content-Type', 'application/xml; charset=utf-8');
+    ctx.set('Cache-Control', 'no-store');
+    ctx.body = xml;
+  },
+
+  async serveManualSitemapFile(ctx) {
+    const filenameParam = ctx.params.filename;
+    const filename = filenameParam ? decodeURIComponent(filenameParam) : '';
+    const service = getManualSitemapService();
+    const sitemaps = await service.getManualSitemaps();
+    const target = sitemaps.find((item) => item.filename === filename);
+
+    if (!target) {
+      return ctx.notFound('Sitemap not found');
+    }
+
+    const configuredBaseUrl = await service.getConfiguredBaseUrl();
+    const origin = getRequestOrigin(ctx);
+    const baseUrl = service.resolveBaseUrl(configuredBaseUrl, origin);
+    const xml = service.buildManualSitemapFile(target, baseUrl);
+    ctx.set('Content-Type', 'application/xml; charset=utf-8');
+    ctx.set('Cache-Control', 'no-store');
+    ctx.body = xml;
+  },
+
+  async serveCollectionSitemapFile(ctx) {
+    const filenameParam = ctx.params.filename;
+    const filename = filenameParam ? decodeURIComponent(filenameParam) : '';
+    const normalizedId = filename.replace(/\.xml$/i, '');
+    const service = getManualSitemapService();
+    const [configs, configuredBaseUrl] = await Promise.all([
+      service.getCollectionConfigs(),
+      service.getConfiguredBaseUrl(),
+    ]);
+    const target = configs.find((item) => String(item.id) === normalizedId);
+
+    if (!target) {
+      return ctx.notFound('Sitemap not found');
+    }
+
+    const origin = getRequestOrigin(ctx);
+    const baseUrl = service.resolveBaseUrl(configuredBaseUrl, origin);
+    const xml = await service.buildCollectionSitemapFile(target, baseUrl);
+
+    ctx.set('Content-Type', 'application/xml; charset=utf-8');
+    ctx.set('Cache-Control', 'no-store');
+    ctx.body = xml;
+  },
+
+  async listCollectionTypes(ctx) {
+    const results = await strapi.entityService.findMany(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-content-type`, { sort: { id: 'desc' } });
+    ctx.body = { results };
+  },
+
+  async createOrUpdateCollectionType(ctx) {
+    const { id, ...payload } = ctx.request.body || {};
+    if (id) {
+      await strapi.entityService.update(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-content-type`, id, { data: payload });
+    } else {
+      await strapi.entityService.create(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-content-type`, { data: payload });
+    }
+    ctx.body = { ok: true };
+  },
+
+  async deleteCollectionType(ctx) {
+    const { id } = ctx.request.query;
+    if (id) {
+      await strapi.entityService.delete(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-content-type`, id);
+    }
+    ctx.body = { ok: true };
+  },
+
+  async listCustomUrls(ctx) {
+    const results = await strapi.entityService.findMany(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-single-url`, { sort: { id: 'desc' } });
+    ctx.body = { results };
+  },
+
+  async createOrUpdateCustomUrl(ctx) {
+    const { id, ...payload } = ctx.request.body || {};
+    if (id) {
+      await strapi.entityService.update(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-single-url`, id, { data: payload });
+    } else {
+      await strapi.entityService.create(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-single-url`, { data: payload });
+    }
+    ctx.body = { ok: true };
+  },
+
+  async deleteCustomUrl(ctx) {
+    const { id } = ctx.request.query;
+    if (id) {
+      await strapi.entityService.delete(`plugin::${PLUGIN_ID}.strapi-advanced-sitemap-single-url`, id);
+    }
+    ctx.body = { ok: true };
+  },
+
+  async listContentTypes(ctx) {
+    const apiTypes = Object.values(strapi.contentTypes)
+      .filter((t) => t.uid?.startsWith('api::'))
+      .map((t) => ({
+        uid: t.uid,
+        singularName: t.info?.singularName || t.uid,
+        displayName: t.info?.displayName || t.uid,
+        kind: t.kind || null,
+      }));
+
+    const collectionTypes = apiTypes.filter((t) => t.kind === 'collectionType');
+    const singleTypes = apiTypes.filter((t) => t.kind === 'singleType');
+
+    ctx.body = { collectionTypes, singleTypes };
+  },
+
+  async listLocales(ctx) {
+    try {
+      const service = strapi.plugin('i18n')?.service('locales');
+      const locales = service ? await service.list() : [];
+      ctx.body = locales;
+    } catch (e) {
+      ctx.body = [];
+    }
+  },
+};

package/dist/server/src/controllers/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  controller: require('./controller'),
+};
+
+

package/dist/server/src/destroy.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  strapi.log.info('Destroying strapi-advanced-sitemap plugin...');
+};
+
+

package/dist/server/src/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+const destroy = require('./destroy');
+const config = require('./config');
+const contentTypes = require('./content-types');
+const controllers = require('./controllers');
+const routes = require('./routes');
+const services = require('./services');
+const middlewares = require('./middlewares');
+const policies = require('./policies');
+
+module.exports = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  contentTypes,
+  policies,
+  middlewares,
+  routes,
+  services,
+};
+
+

package/dist/server/src/middlewares/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  'permission-check': require('./permission-check'),
+};
+
+

package/dist/server/src/middlewares/permission-check.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { ensureSitemapPermission } = require('../utils/check-sitemap-permission');
+
+module.exports = () => {
+  return async (ctx, next) => {
+    const actionKey = ctx?.state?.route?.info?.permissionAction;
+
+    if (!actionKey) {
+      return next();
+    }
+
+    const allowed = await ensureSitemapPermission(ctx, actionKey);
+
+    if (allowed) {
+      return next();
+    }
+  };
+};
+

package/dist/server/src/policies/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {};
+
+

package/dist/server/src/register.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = async ({ strapi }) => {
+  strapi.log.info('Registering strapi-advanced-sitemap plugin...');
+};
+
+
+

package/dist/server/src/routes/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+module.exports = {
+  admin: {
+    routes: [
+      { method: 'GET', path: '/admin-get-options', handler: 'controller.getOptions', config: { policies: [] } },
+      { method: 'PUT', path: '/admin-put-options', handler: 'controller.putOptions', config: { policies: [] } },
+
+      { method: 'GET', path: '/manual-sitemaps', handler: 'controller.getManualSitemaps', config: { policies: [] } },
+      { method: 'PUT', path: '/manual-sitemaps', handler: 'controller.putManualSitemaps', config: { policies: [] } },
+
+      { method: 'GET', path: '/admin', handler: 'controller.listCollectionTypes', config: { policies: [] } },
+      { method: 'POST', path: '/admin', handler: 'controller.createOrUpdateCollectionType', config: { policies: [] } },
+      { method: 'DELETE', path: '/admin', handler: 'controller.deleteCollectionType', config: { policies: [] } },
+
+      { method: 'GET', path: '/admin-custom-urls', handler: 'controller.listCustomUrls', config: { policies: [] } },
+      { method: 'POST', path: '/admin-custom-urls', handler: 'controller.createOrUpdateCustomUrl', config: { policies: [] } },
+      { method: 'DELETE', path: '/admin-custom-urls', handler: 'controller.deleteCustomUrl', config: { policies: [] } },
+
+      { method: 'GET', path: '/admin-get-content-types', handler: 'controller.listContentTypes', config: { policies: [] } },
+      { method: 'GET', path: '/admin-get-locales', handler: 'controller.listLocales', config: { policies: [] } },
+    ],
+  },
+  'content-api': {
+    routes: [
+      {
+        method: 'GET',
+        path: '/sitemap.xml',
+        handler: 'controller.serveRootSitemap',
+        info: { type: 'content-api', pluginName: 'strapi-advanced-sitemap', permissionAction: 'root' },
+        config: {
+          auth: false,
+          middlewares: ['plugin::strapi-advanced-sitemap.permission-check'],
+          policies: [],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/manual-sitemaps',
+        handler: 'controller.serveManualSitemapIndex',
+        info: { type: 'content-api', pluginName: 'strapi-advanced-sitemap', permissionAction: 'manualIndex' },
+        config: {
+          auth: false,
+          middlewares: ['plugin::strapi-advanced-sitemap.permission-check'],
+          policies: [],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/manual-sitemaps/:filename',
+        handler: 'controller.serveManualSitemapFile',
+        info: { type: 'content-api', pluginName: 'strapi-advanced-sitemap', permissionAction: 'manualFile' },
+        config: {
+          auth: false,
+          middlewares: ['plugin::strapi-advanced-sitemap.permission-check'],
+          policies: [],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/collection-sitemaps/:filename',
+        handler: 'controller.serveCollectionSitemapFile',
+        info: { type: 'content-api', pluginName: 'strapi-advanced-sitemap', permissionAction: 'collectionFile' },
+        config: {
+          auth: false,
+          middlewares: ['plugin::strapi-advanced-sitemap.permission-check'],
+          policies: [],
+        },
+      },
+    ],
+  },
+};
+
+

package/dist/server/src/services/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  service: require('./service'),
+};
+
+