@vicacha-devs/strapi-plugin-seo 0.0.0-stage → 2.0.12

package/dist/server/index.cjs

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const bootstrap = async ({ strapi }) => {
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Access the SEO plugin",
+      uid: "read",
+      pluginName: "seo"
+    },
+    {
+      section: "plugins",
+      displayName: "Manage SEO plugin settings",
+      uid: "settings.update",
+      pluginName: "seo"
+    }
+  ];
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const seoController = ({ strapi }) => ({
+  findSeoComponent(ctx) {
+    ctx.body = strapi.plugin("seo").service("seo").getSeoComponent();
+    return ctx.body;
+  },
+  findContentTypes(ctx) {
+    ctx.body = strapi.plugin("seo").service("seo").getContentTypes();
+    return ctx.body;
+  },
+  async createSeoComponent(ctx) {
+    const previousWatching = strapi.reload?.isWatching;
+    if (strapi.reload) {
+      strapi.reload.isWatching = false;
+    }
+    try {
+      const data = await strapi.plugin("seo").service("seo").createSeoComponent();
+      if (!data) {
+        if (strapi.reload && previousWatching !== void 0) {
+          strapi.reload.isWatching = previousWatching;
+        }
+        ctx.status = 500;
+        ctx.body = { error: "Failed to create SEO component" };
+        return ctx.body;
+      }
+      if (typeof strapi.reload === "function") {
+        setImmediate(() => strapi.reload());
+      }
+      ctx.body = data;
+      return data;
+    } catch (error) {
+      if (strapi.reload && previousWatching !== void 0) {
+        strapi.reload.isWatching = previousWatching;
+      }
+      strapi.log?.error?.(String(error));
+      if (typeof ctx.throw === "function") {
+        ctx.throw(500, error);
+      }
+      ctx.status = 500;
+      ctx.body = { error: "Failed to create SEO component" };
+      return ctx.body;
+    }
+  }
+});
+const isPlainRecord$1 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const settingsController = ({ strapi }) => {
+  const getSettingsService = () => strapi.plugin("seo").service("settings");
+  const getSettings = async (ctx) => {
+    try {
+      const result = await getSettingsService().getSettings();
+      ctx.body = result;
+      return result;
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  };
+  const setSettings = async (ctx) => {
+    const { body } = ctx.request ?? {};
+    if (!isPlainRecord$1(body)) {
+      if (typeof ctx.badRequest === "function") {
+        return ctx.badRequest("Invalid SEO settings payload");
+      }
+      return ctx.throw(400, "Invalid SEO settings payload");
+    }
+    try {
+      const settingsService2 = getSettingsService();
+      await settingsService2.setSettings(body);
+      const updated = await settingsService2.getSettings();
+      ctx.body = updated;
+      return updated;
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  };
+  return {
+    getSettings,
+    setSettings
+  };
+};
+const controllers = {
+  seo: seoController,
+  settings: settingsController
+};
+const destroy = (_context) => {
+};
+const register = (_context) => {
+};
+const READ_POLICIES = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::seo.read"] }
+  }
+];
+const seoRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/component",
+      handler: "seo.findSeoComponent",
+      config: {
+        policies: READ_POLICIES
+      }
+    },
+    {
+      method: "POST",
+      path: "/component",
+      handler: "seo.createSeoComponent",
+      config: {
+        policies: READ_POLICIES
+      }
+    },
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "seo.findContentTypes",
+      config: {
+        policies: READ_POLICIES
+      }
+    }
+  ]
+};
+const SETTINGS_POLICIES = [
+  "admin::isAuthenticatedAdmin",
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::seo.read"] }
+  }
+];
+const settingsRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.getSettings",
+      config: { policies: SETTINGS_POLICIES }
+    },
+    {
+      method: "POST",
+      path: "/settings",
+      handler: "settings.setSettings",
+      config: { policies: SETTINGS_POLICIES }
+    }
+  ]
+};
+const routes = {
+  seo: seoRoutes,
+  settings: settingsRoutes
+};
+const collectionName$1 = "components_shared_open_graphs";
+const info$1 = { "displayName": "openGraph", "icon": "project-diagram" };
+const options$1 = {};
+const attributes$1 = { "ogTitle": { "type": "string", "required": true, "maxLength": 70 }, "ogDescription": { "type": "string", "maxLength": 200, "required": true }, "ogImage": { "allowedTypes": ["images"], "type": "media", "multiple": false }, "ogUrl": { "type": "string", "required": false }, "ogType": { "type": "string", "required": false } };
+const openGraph = {
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  attributes: attributes$1
+};
+const collectionName = "components_shared_seos";
+const info = { "displayName": "seo", "icon": "search" };
+const options = {};
+const attributes = { "metaTitle": { "required": true, "type": "string", "maxLength": 60 }, "metaDescription": { "type": "string", "required": true, "maxLength": 160, "minLength": 50 }, "metaImage": { "type": "media", "multiple": false, "required": false, "allowedTypes": ["images"] }, "openGraph": { "type": "component", "repeatable": false, "component": "shared.open-graph" }, "keywords": { "type": "text", "regex": "[^,]+" }, "metaRobots": { "type": "string", "regex": "[^,]+" }, "metaViewport": { "type": "string" }, "canonicalURL": { "type": "string" }, "structuredData": { "type": "json" } };
+const seoContent = {
+  collectionName,
+  info,
+  options,
+  attributes
+};
+const BLACKLISTED_PLUGINS = [
+  "upload",
+  "i18n",
+  "users-permissions",
+  "content-releases",
+  "review-workflows",
+  "email",
+  "seo",
+  "email-designer-5"
+];
+const isContentManagerVisible = (ct) => {
+  const pluginOptions = ct.__schema__?.pluginOptions ?? ct.pluginOptions;
+  return pluginOptions?.["content-manager"]?.visible !== false;
+};
+const shouldIncludeContentType = (name, ct) => {
+  if (name.startsWith("api::")) return true;
+  return name.startsWith("plugin::") && isContentManagerVisible(ct);
+};
+const resolveGlobalId = (name, ct) => {
+  if (ct.globalId) return ct.globalId;
+  return ct.info?.displayName ?? name;
+};
+const hasSeoComponentAttribute = (ct) => {
+  const seoAttr = ct.attributes?.seo;
+  return typeof seoAttr?.component === "string" && seoAttr.component.trim().length > 0;
+};
+const buildContentTypeSeoItem = (name, ct) => ({
+  seo: hasSeoComponentAttribute(ct),
+  uid: ct.uid ?? name,
+  kind: ct.kind ?? "collectionType",
+  globalId: resolveGlobalId(name, ct),
+  attributes: ct.attributes ?? {}
+});
+const isAllowedPluginContentType = (name) => {
+  const pluginPrefix = name.replace("plugin::", "").split(".")[0];
+  return !BLACKLISTED_PLUGINS.includes(pluginPrefix);
+};
+const seoService = ({ strapi }) => ({
+  getSeoComponent() {
+    const seoComponent = strapi.components?.["shared.seo"];
+    return seoComponent ? { attributes: seoComponent.attributes, category: seoComponent.category } : null;
+  },
+  getContentTypes() {
+    const contentTypes = strapi.contentTypes || {};
+    const keys = Object.keys(contentTypes);
+    const collectionTypes = [];
+    const singleTypes = [];
+    const plugins = [];
+    keys.forEach((name) => {
+      const ct = contentTypes[name];
+      if (!ct || !shouldIncludeContentType(name, ct)) return;
+      const object = buildContentTypeSeoItem(name, ct);
+      if (name.startsWith("api::")) {
+        const targetList = ct.kind === "collectionType" ? collectionTypes : singleTypes;
+        targetList.push(object);
+      } else if (isAllowedPluginContentType(name)) {
+        plugins.push(object);
+      }
+    });
+    return { collectionTypes, singleTypes, plugins };
+  },
+  async createSeoComponent() {
+    const seoComponent = await this.getSeoComponent();
+    if (seoComponent) {
+      return seoComponent;
+    }
+    if (!openGraph || !seoContent) {
+      return null;
+    }
+    const hasOpenGraph = Boolean(strapi.components?.["shared.open-graph"]);
+    try {
+      return await strapi.plugin("content-type-builder").services.components.createComponent({
+        component: {
+          category: "shared",
+          displayName: seoContent.info.displayName,
+          icon: seoContent.info.icon,
+          attributes: seoContent.attributes
+        },
+        components: hasOpenGraph ? [] : [
+          {
+            tmpUID: "shared.open-graph",
+            category: "shared",
+            displayName: openGraph.info.displayName,
+            icon: openGraph.info.icon,
+            attributes: openGraph.attributes
+          }
+        ]
+      });
+    } catch (error) {
+      strapi.log?.error?.(String(error));
+      return null;
+    }
+  }
+});
+const DEFAULT_SEO_CHECKS = {
+  metaTitle: true,
+  metaDescription: true,
+  metaRobots: true,
+  openGraph: true,
+  wordCount: true,
+  canonicalUrl: true,
+  keywordDensity: true,
+  structuredData: true,
+  alternativeText: true,
+  lastUpdatedAt: true
+};
+const FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+const SEO_CHECK_KEYS = Object.keys(DEFAULT_SEO_CHECKS);
+const isPlainRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const sanitizeSeoChecks = (raw) => {
+  const source = isPlainRecord(raw) ? raw : {};
+  const checks = { ...DEFAULT_SEO_CHECKS };
+  SEO_CHECK_KEYS.forEach((key) => {
+    if (typeof source[key] === "boolean") {
+      checks[key] = source[key];
+    }
+  });
+  return checks;
+};
+const sanitizeSeoSettingsMap = (raw) => {
+  const result = {};
+  if (!isPlainRecord(raw)) {
+    return result;
+  }
+  Object.keys(raw).forEach((key) => {
+    const trimmedKey = key.trim();
+    if (!trimmedKey || trimmedKey.length > 128 || FORBIDDEN_KEYS.has(trimmedKey)) {
+      return;
+    }
+    const entry = raw[key];
+    if (!isPlainRecord(entry)) {
+      return;
+    }
+    const fallbackName = trimmedKey.split(".").pop() || trimmedKey;
+    const rawName = entry.collectionName;
+    const collectionName2 = typeof rawName === "string" && rawName.trim().length > 0 ? rawName.trim().slice(0, 128) : fallbackName;
+    result[trimmedKey] = {
+      collectionName: collectionName2,
+      seoChecks: sanitizeSeoChecks(entry.seoChecks)
+    };
+  });
+  return result;
+};
+const settingsService = ({ strapi }) => {
+  const getPluginStore = () => {
+    return strapi.store({
+      environment: "",
+      type: "plugin",
+      name: "seo"
+    });
+  };
+  const createDefaultConfig = async () => {
+    const pluginStore = getPluginStore();
+    const newContentTypes = {};
+    const keys = Object.keys(strapi.contentTypes || {});
+    keys.forEach((key) => {
+      if (key.includes("api::") || key.includes("plugin::")) {
+        newContentTypes[key] = {
+          collectionName: key.split(".").pop() || key,
+          seoChecks: { ...DEFAULT_SEO_CHECKS }
+        };
+      }
+    });
+    await pluginStore.set({ key: "settings", value: newContentTypes });
+    return pluginStore.get({ key: "settings" });
+  };
+  const getSettings = async () => {
+    const pluginStore = getPluginStore();
+    const stored = await pluginStore.get({ key: "settings" });
+    if (!isPlainRecord(stored)) {
+      return createDefaultConfig();
+    }
+    const config2 = sanitizeSeoSettingsMap(stored);
+    let updated = false;
+    const keys = Object.keys(strapi.contentTypes || {});
+    keys.forEach((key) => {
+      if ((key.includes("api::") || key.includes("plugin::")) && !Object.prototype.hasOwnProperty.call(config2, key)) {
+        config2[key] = {
+          collectionName: key.split(".").pop() || key,
+          seoChecks: { ...DEFAULT_SEO_CHECKS }
+        };
+        updated = true;
+      }
+    });
+    if (updated) {
+      await pluginStore.set({ key: "settings", value: config2 });
+    }
+    return config2;
+  };
+  const setSettings = async (data) => {
+    const pluginStore = getPluginStore();
+    const sanitized = sanitizeSeoSettingsMap(data);
+    const existingRaw = await pluginStore.get({
+      key: "settings"
+    });
+    const existing = isPlainRecord(existingRaw) ? sanitizeSeoSettingsMap(existingRaw) : {};
+    const merged = {
+      ...existing,
+      ...sanitized
+    };
+    await pluginStore.set({ key: "settings", value: merged });
+    return pluginStore.get({ key: "settings" });
+  };
+  return {
+    getSettings,
+    setSettings
+  };
+};
+const services = {
+  seo: seoService,
+  settings: settingsService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services
+};
+exports.default = index;

package/dist/server/index.d.ts

@@ -0,0 +1,83 @@
+declare const _default: {
+    register: (_context: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => Promise<void>;
+    destroy: (_context: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    config: {
+        default: {};
+        validator(): void;
+    };
+    controllers: {
+        seo: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            findSeoComponent(ctx: import('./controllers/seo').SeoControllerContext): unknown;
+            findContentTypes(ctx: import('./controllers/seo').SeoControllerContext): unknown;
+            createSeoComponent(ctx: import('./controllers/seo').SeoControllerContext): Promise<unknown>;
+        };
+        settings: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettings: (ctx: import('./controllers/settings').SettingsControllerContext) => Promise<import('../../shared').SeoSettingsMap | undefined>;
+            setSettings: (ctx: import('./controllers/settings').SettingsControllerContext) => Promise<unknown>;
+        };
+    };
+    routes: {
+        seo: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+        settings: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+    services: {
+        seo: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSeoComponent(): {
+                attributes: Record<string, unknown> | undefined;
+                category: string | undefined;
+            } | null;
+            getContentTypes(): import('../../shared').ContentTypesResponse;
+            createSeoComponent(): Promise<unknown>;
+        };
+        settings: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettings: () => Promise<import('../../shared').SeoSettingsMap>;
+            setSettings: (data: import('../../shared').SeoSettingsMap) => Promise<import('../../shared').SeoSettingsMap>;
+        };
+    };
+};
+export default _default;