@orion-studios/payload-seo-audit 1.0.0 → 1.1.1

package/dist/globals/SeoIntegrations.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeoIntegrations = void 0;
+const access_1 = require("../utilities/access");
+const secrets_1 = require("../utilities/secrets");
+const secretPaths = [
+    'gsc.oauthClientSecret',
+    'gsc.oauthRefreshToken',
+    'gsc.serviceAccountPrivateKey',
+    'pageSpeed.apiKey',
+    'crux.apiKey',
+    'authority.dataForSeoLogin',
+    'authority.dataForSeoPassword',
+    'ops.webhookSecret',
+];
+exports.SeoIntegrations = {
+    slug: 'seo-integrations',
+    label: 'SEO Integrations',
+    admin: {
+        group: 'SEO',
+        description: 'Configure API integrations for Search Console, PageSpeed, CrUX, and authority providers.',
+    },
+    access: {
+        read: access_1.seoAdminAccess,
+        update: access_1.seoAdminAccess,
+    },
+    hooks: {
+        beforeChange: [
+            async ({ data, originalDoc, req }) => {
+                if (!data || typeof data !== 'object')
+                    return data;
+                return (0, secrets_1.encryptSecretPaths)({
+                    data: data,
+                    originalDoc: originalDoc || undefined,
+                    secretPaths,
+                    payload: req.payload,
+                });
+            },
+        ],
+        afterRead: [
+            async ({ doc, req }) => {
+                if (!doc || typeof doc !== 'object')
+                    return doc;
+                return (0, secrets_1.maskSecretPaths)({
+                    doc: doc,
+                    secretPaths,
+                    req: req,
+                });
+            },
+        ],
+    },
+    fields: [
+        {
+            name: 'gsc',
+            type: 'group',
+            label: 'Google Search Console',
+            fields: [
+                {
+                    name: 'enabled',
+                    type: 'checkbox',
+                    defaultValue: false,
+                },
+                {
+                    name: 'authMode',
+                    type: 'select',
+                    defaultValue: 'oauth',
+                    options: [
+                        { label: 'OAuth Refresh Token', value: 'oauth' },
+                        { label: 'Service Account', value: 'service-account' },
+                    ],
+                },
+                {
+                    name: 'siteUrlOverride',
+                    type: 'text',
+                    admin: {
+                        description: 'Optional site URL for GSC queries. Defaults to canonical host.',
+                    },
+                },
+                {
+                    name: 'rowLimit',
+                    type: 'number',
+                    defaultValue: 250,
+                    min: 25,
+                    max: 25000,
+                },
+                {
+                    name: 'lookbackDays',
+                    type: 'number',
+                    defaultValue: 7,
+                    min: 1,
+                    max: 90,
+                },
+                {
+                    name: 'oauthClientID',
+                    type: 'text',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.authMode === 'oauth',
+                    },
+                },
+                {
+                    name: 'oauthClientSecret',
+                    type: 'text',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.authMode === 'oauth',
+                    },
+                },
+                {
+                    name: 'oauthRedirectURI',
+                    type: 'text',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.authMode === 'oauth',
+                    },
+                },
+                {
+                    name: 'oauthRefreshToken',
+                    type: 'textarea',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.authMode === 'oauth',
+                    },
+                },
+                {
+                    name: 'serviceAccountEmail',
+                    type: 'text',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.authMode === 'service-account',
+                    },
+                },
+                {
+                    name: 'serviceAccountPrivateKey',
+                    type: 'textarea',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.authMode === 'service-account',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'pageSpeed',
+            type: 'group',
+            label: 'Google PageSpeed Insights',
+            fields: [
+                {
+                    name: 'enabled',
+                    type: 'checkbox',
+                    defaultValue: true,
+                },
+                {
+                    name: 'apiKey',
+                    type: 'text',
+                    admin: {
+                        description: 'Optional but recommended for stable quota.',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'crux',
+            type: 'group',
+            label: 'Chrome UX Report (CrUX)',
+            fields: [
+                {
+                    name: 'enabled',
+                    type: 'checkbox',
+                    defaultValue: false,
+                },
+                {
+                    name: 'apiKey',
+                    type: 'text',
+                },
+                {
+                    name: 'queryScope',
+                    type: 'select',
+                    defaultValue: 'origin+key-urls',
+                    options: [
+                        { label: 'Origin + Key URLs', value: 'origin+key-urls' },
+                        { label: 'Origin Only', value: 'origin-only' },
+                        { label: 'Key URLs Only', value: 'key-urls-only' },
+                    ],
+                },
+                {
+                    name: 'formFactor',
+                    type: 'select',
+                    defaultValue: 'ALL_FORM_FACTORS',
+                    options: [
+                        { label: 'All Form Factors', value: 'ALL_FORM_FACTORS' },
+                        { label: 'Phone', value: 'PHONE' },
+                        { label: 'Desktop', value: 'DESKTOP' },
+                    ],
+                },
+                {
+                    name: 'countryCode',
+                    type: 'text',
+                    admin: {
+                        description: 'Optional two-letter ISO country code (for example: US).',
+                    },
+                },
+                {
+                    name: 'lookbackWindowDays',
+                    type: 'number',
+                    defaultValue: 28,
+                    min: 1,
+                    max: 180,
+                },
+            ],
+        },
+        {
+            name: 'authority',
+            type: 'group',
+            label: 'Authority Provider',
+            fields: [
+                {
+                    name: 'enabled',
+                    type: 'checkbox',
+                    defaultValue: false,
+                },
+                {
+                    name: 'provider',
+                    type: 'select',
+                    defaultValue: 'none',
+                    options: [
+                        { label: 'None', value: 'none' },
+                        { label: 'DataForSEO', value: 'dataforseo' },
+                    ],
+                },
+                {
+                    name: 'captureTopBacklinksLimit',
+                    type: 'number',
+                    defaultValue: 100,
+                    min: 10,
+                    max: 1000,
+                },
+                {
+                    name: 'runPolicy',
+                    type: 'select',
+                    defaultValue: 'manual+scheduled',
+                    options: [
+                        { label: 'Manual + Scheduled', value: 'manual+scheduled' },
+                        { label: 'Scheduled Only', value: 'scheduled-only' },
+                        { label: 'All Run Types', value: 'all' },
+                    ],
+                },
+                {
+                    name: 'dataForSeoLogin',
+                    type: 'text',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.provider === 'dataforseo',
+                    },
+                },
+                {
+                    name: 'dataForSeoPassword',
+                    type: 'text',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.provider === 'dataforseo',
+                    },
+                },
+                {
+                    name: 'dataForSeoBaseURL',
+                    type: 'text',
+                    defaultValue: 'https://api.dataforseo.com',
+                    admin: {
+                        condition: (_, siblingData) => siblingData?.provider === 'dataforseo',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'ops',
+            type: 'group',
+            label: 'Operator Webhook (Private)',
+            fields: [
+                {
+                    name: 'enabled',
+                    type: 'checkbox',
+                    defaultValue: false,
+                },
+                {
+                    name: 'webhookURL',
+                    type: 'text',
+                },
+                {
+                    name: 'webhookSecret',
+                    type: 'text',
+                },
+                {
+                    name: 'sendPerRun',
+                    type: 'checkbox',
+                    defaultValue: true,
+                },
+                {
+                    name: 'sendMonthlyRollup',
+                    type: 'checkbox',
+                    defaultValue: true,
+                },
+                {
+                    name: 'lastRollupMonth',
+                    type: 'text',
+                    admin: {
+                        readOnly: true,
+                        hidden: true,
+                    },
+                },
+            ],
+        },
+    ],
+};

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAazE,YAAY,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAsCpD,eAAO,MAAM,cAAc,GAAI,cAAc,oBAAoB,MACvD,gBAAgB,MAAM,KAAG,MA+BlC,CAAA;AAMD,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,GAAG,mBAAmB,GAAG,IAAI,CAErE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAYzE,YAAY,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEpD,eAAO,MAAM,cAAc,GAAI,cAAc,oBAAoB,MACvD,gBAAgB,MAAM,KAAG,MAwBlC,CAAA;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,GAAG,mBAAmB,GAAG,IAAI,CAErE"}

package/dist/index.js

@@ -7,21 +7,21 @@ const SeoSnapshots_1 = require("./collections/SeoSnapshots");
 const SeoPageResults_1 = require("./collections/SeoPageResults");
 const SeoKeywordVisibility_1 = require("./collections/SeoKeywordVisibility");
 const SeoAuthoritySnapshots_1 = require("./collections/SeoAuthoritySnapshots");
+const SeoDashboardView_1 = require("./collections/SeoDashboardView");
 const SeoDashboard_1 = require("./globals/SeoDashboard");
+const SeoIntegrations_1 = require("./globals/SeoIntegrations");
 const seoAuditPlugin = (pluginConfig) => {
     return (incomingConfig) => {
         const seoConfig = (0, config_1.normalizeConfig)(pluginConfig);
         const collections = [
             ...(incomingConfig.collections || []),
+            SeoDashboardView_1.SeoDashboardView,
             SeoSnapshots_1.SeoSnapshots,
             SeoPageResults_1.SeoPageResults,
             SeoKeywordVisibility_1.SeoKeywordVisibility,
             SeoAuthoritySnapshots_1.SeoAuthoritySnapshots,
         ];
-        const globals = [
-            ...(incomingConfig.globals || []),
-            SeoDashboard_1.SeoDashboard,
-        ];
+        const globals = [...(incomingConfig.globals || []), SeoDashboard_1.SeoDashboard, SeoIntegrations_1.SeoIntegrations];
         return {
             ...incomingConfig,
             collections,

package/dist/utilities/crux.d.ts

@@ -0,0 +1,6 @@
+import type { CrUXSyncResult, IntegrationSettings, SEOSiteRecord } from '../utilities/types';
+export declare const getCruxSummary: ({ site, settings, }: {
+    site: SEOSiteRecord;
+    settings: IntegrationSettings;
+}) => Promise<CrUXSyncResult>;
+//# sourceMappingURL=crux.d.ts.map

package/dist/utilities/crux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crux.d.ts","sourceRoot":"","sources":["../../src/utilities/crux.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,cAAc,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAsLzG,eAAO,MAAM,cAAc,GAAU,qBAGlC;IACD,IAAI,EAAE,aAAa,CAAA;IACnB,QAAQ,EAAE,mBAAmB,CAAA;CAC9B,KAAG,OAAO,CAAC,cAAc,CA2HzB,CAAA"}

package/dist/utilities/crux.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCruxSummary = void 0;
+const CRUX_ENDPOINT = 'https://chromeuxreport.googleapis.com/v1/records:queryRecord';
+const normalizeCLS = (value) => {
+    if (typeof value !== 'number' || Number.isNaN(value))
+        return undefined;
+    if (value > 1)
+        return Number((value / 100).toFixed(3));
+    return Number(value.toFixed(3));
+};
+const parsePercentile = (metric) => {
+    const p75 = Number(metric?.percentiles?.p75 ?? metric?.percentile ?? metric?.p75);
+    if (!Number.isFinite(p75))
+        return undefined;
+    return p75;
+};
+const calculateGoodPercentage = ({ metric, threshold, normalize, }) => {
+    const histogram = metric?.histogram;
+    if (!Array.isArray(histogram) || !histogram.length)
+        return undefined;
+    let good = 0;
+    for (const bucket of histogram) {
+        const density = Number(bucket?.density);
+        if (!Number.isFinite(density) || density <= 0)
+            continue;
+        const start = normalize(Number(bucket?.start));
+        const end = normalize(Number(bucket?.end));
+        if (typeof start !== 'number' || typeof end !== 'number')
+            continue;
+        if (threshold >= end) {
+            good += density;
+            continue;
+        }
+        if (threshold <= start) {
+            continue;
+        }
+        const span = end - start;
+        if (span <= 0) {
+            continue;
+        }
+        const proportional = (threshold - start) / span;
+        if (proportional > 0) {
+            good += density * proportional;
+        }
+    }
+    return Number((good * 100).toFixed(1));
+};
+const parseCruxRecord = (record) => {
+    const metrics = record?.metrics;
+    if (!metrics || typeof metrics !== 'object')
+        return null;
+    const lcpMetric = metrics?.largest_contentful_paint;
+    const inpMetric = metrics?.interaction_to_next_paint;
+    const clsMetric = metrics?.cumulative_layout_shift;
+    const lcpP75 = parsePercentile(lcpMetric);
+    const inpP75 = parsePercentile(inpMetric);
+    const clsP75Raw = parsePercentile(clsMetric);
+    const clsP75 = normalizeCLS(clsP75Raw);
+    return {
+        lcp: {
+            p75: Number.isFinite(lcpP75) ? lcpP75 : undefined,
+            goodPct: calculateGoodPercentage({
+                metric: lcpMetric,
+                threshold: 2500,
+                normalize: (value) => value,
+            }),
+        },
+        inp: {
+            p75: Number.isFinite(inpP75) ? inpP75 : undefined,
+            goodPct: calculateGoodPercentage({
+                metric: inpMetric,
+                threshold: 200,
+                normalize: (value) => value,
+            }),
+        },
+        cls: {
+            p75: clsP75,
+            goodPct: calculateGoodPercentage({
+                metric: clsMetric,
+                threshold: 0.1,
+                normalize: normalizeCLS,
+            }),
+        },
+    };
+};
+const queryCruxRecord = async ({ apiKey, formFactor, countryCode, origin, url, }) => {
+    const endpoint = new URL(CRUX_ENDPOINT);
+    endpoint.searchParams.set('key', apiKey);
+    const body = {
+        formFactor,
+    };
+    if (origin) {
+        body.origin = origin;
+    }
+    if (url) {
+        body.url = url;
+    }
+    if (countryCode) {
+        body.country = countryCode;
+    }
+    const response = await fetch(endpoint.toString(), {
+        method: 'POST',
+        cache: 'no-store',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`CrUX API request failed with status ${response.status}`);
+    }
+    const json = (await response.json());
+    return parseCruxRecord(json.record);
+};
+const averageMetric = (values) => {
+    const valid = values.filter((value) => typeof value === 'number' && Number.isFinite(value));
+    if (!valid.length)
+        return undefined;
+    return Number((valid.reduce((sum, value) => sum + value, 0) / valid.length).toFixed(2));
+};
+const defaultSummary = () => ({
+    cruxAvailable: false,
+    cruxSource: 'none',
+    cruxSampleUrlsChecked: 0,
+    cruxSampleUrlsWithData: 0,
+});
+const getCruxSummary = async ({ site, settings, }) => {
+    if (!settings.crux.enabled) {
+        return {
+            enabled: false,
+            available: false,
+            skipped: 'disabled',
+            summary: defaultSummary(),
+        };
+    }
+    const apiKey = settings.crux.apiKey.trim();
+    if (!apiKey) {
+        return {
+            enabled: true,
+            available: false,
+            skipped: 'missing-api-key',
+            summary: defaultSummary(),
+        };
+    }
+    const canonicalHost = (site.canonicalHost || '').trim();
+    if (!canonicalHost) {
+        return {
+            enabled: true,
+            available: false,
+            skipped: 'missing-site-host',
+            summary: defaultSummary(),
+        };
+    }
+    const origin = (() => {
+        try {
+            return new URL(canonicalHost).origin;
+        }
+        catch {
+            return canonicalHost;
+        }
+    })();
+    const sampleUrls = (site.keyURLs || [])
+        .map((entry) => entry?.url?.trim())
+        .filter((value) => Boolean(value))
+        .slice(0, 5);
+    const includeOrigin = settings.crux.queryScope !== 'key-urls-only';
+    const includeUrls = settings.crux.queryScope !== 'origin-only';
+    try {
+        const records = [];
+        let urlChecks = 0;
+        let urlHits = 0;
+        let hasOriginData = false;
+        if (includeOrigin) {
+            const originRecord = await queryCruxRecord({
+                apiKey,
+                formFactor: settings.crux.formFactor,
+                countryCode: settings.crux.countryCode || undefined,
+                origin,
+            });
+            if (originRecord) {
+                hasOriginData = true;
+                records.push(originRecord);
+            }
+        }
+        if (includeUrls) {
+            for (const url of sampleUrls) {
+                urlChecks += 1;
+                const record = await queryCruxRecord({
+                    apiKey,
+                    formFactor: settings.crux.formFactor,
+                    countryCode: settings.crux.countryCode || undefined,
+                    url,
+                });
+                if (record) {
+                    urlHits += 1;
+                    records.push(record);
+                }
+            }
+        }
+        if (!records.length) {
+            return {
+                enabled: true,
+                available: false,
+                skipped: 'no-data',
+                summary: {
+                    ...defaultSummary(),
+                    cruxSampleUrlsChecked: urlChecks,
+                    cruxSampleUrlsWithData: urlHits,
+                },
+            };
+        }
+        const summary = {
+            cruxAvailable: true,
+            cruxSource: hasOriginData && urlHits > 0 ? 'mixed' : hasOriginData ? 'origin' : 'url',
+            cruxP75LCPMs: averageMetric(records.map((record) => record.lcp.p75)),
+            cruxP75INPMs: averageMetric(records.map((record) => record.inp.p75)),
+            cruxP75CLS: averageMetric(records.map((record) => record.cls.p75)),
+            cruxGoodLCPPct: averageMetric(records.map((record) => record.lcp.goodPct)),
+            cruxGoodINPPct: averageMetric(records.map((record) => record.inp.goodPct)),
+            cruxGoodCLSPct: averageMetric(records.map((record) => record.cls.goodPct)),
+            cruxSampleUrlsChecked: urlChecks,
+            cruxSampleUrlsWithData: urlHits,
+        };
+        return {
+            enabled: true,
+            available: true,
+            summary,
+        };
+    }
+    catch (error) {
+        return {
+            enabled: true,
+            available: false,
+            skipped: 'request-failed',
+            error: error instanceof Error ? error.message : String(error),
+            summary: defaultSummary(),
+        };
+    }
+};
+exports.getCruxSummary = getCruxSummary;

package/dist/utilities/dataforseo.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from 'payload';
+import type { AuthoritySyncResult, IntegrationSettings, SEOSiteRecord } from '../utilities/types';
+export declare const syncDataForSEOAuthoritySnapshot: ({ payload, site, settings, }: {
+    payload: Payload;
+    site: SEOSiteRecord;
+    settings: IntegrationSettings;
+}) => Promise<AuthoritySyncResult>;
+export declare const shouldRunAuthoritySync: ({ runType, settings, }: {
+    runType: "manual" | "scheduled" | "publish-triggered";
+    settings: IntegrationSettings;
+}) => boolean;
+//# sourceMappingURL=dataforseo.d.ts.map

package/dist/utilities/dataforseo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataforseo.d.ts","sourceRoot":"","sources":["../../src/utilities/dataforseo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAkEjG,eAAO,MAAM,+BAA+B,GAAU,8BAInD;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,QAAQ,EAAE,mBAAmB,CAAA;CAC9B,KAAG,OAAO,CAAC,mBAAmB,CAqI9B,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,wBAGpC;IACD,OAAO,EAAE,QAAQ,GAAG,WAAW,GAAG,mBAAmB,CAAA;IACrD,QAAQ,EAAE,mBAAmB,CAAA;CAC9B,YAMA,CAAA"}