@sonordev/site-kit 1.2.7

package/dist/blog/server.mjs

@@ -0,0 +1,666 @@
+import '../chunk-4XPGGLVP.mjs';
+
+// src/blog/server.ts
+function getConfig() {
+  return {
+    apiUrl: process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com",
+    apiKey: process.env.NEXT_PUBLIC_UPTRADE_API_KEY || ""
+  };
+}
+var SEO_LIMITS = {
+  title: { min: 30, max: 60, recommended: 55 },
+  metaDescription: { min: 120, max: 160, recommended: 155 },
+  excerpt: { min: 100, max: 300, recommended: 200 },
+  slug: { max: 75 },
+  focusKeyphrase: { min: 2, max: 4, words: true }
+  // 2-4 words
+};
+function validateSeoTitle(title, focusKeyphrase) {
+  const length = title.length;
+  let status = "good";
+  let message = "Title length is optimal";
+  if (length > SEO_LIMITS.title.max) {
+    status = "error";
+    message = `Title is ${length - SEO_LIMITS.title.max} characters too long (max ${SEO_LIMITS.title.max})`;
+  } else if (length < SEO_LIMITS.title.min) {
+    status = "warning";
+    message = `Title is short (${length}/${SEO_LIMITS.title.min} min)`;
+  } else if (focusKeyphrase && !title.toLowerCase().includes(focusKeyphrase.toLowerCase())) {
+    status = "warning";
+    message = "Focus keyphrase not found in title";
+  } else if (focusKeyphrase && !title.toLowerCase().startsWith(focusKeyphrase.toLowerCase())) {
+    status = "warning";
+    message = "Title should start with focus keyphrase for best results";
+  }
+  return { field: "title", value: title, length, limit: SEO_LIMITS.title, status, message };
+}
+function validateMetaDescription(description, focusKeyphrase) {
+  const length = description.length;
+  let status = "good";
+  let message = "Meta description is optimal";
+  if (length > SEO_LIMITS.metaDescription.max) {
+    status = "error";
+    message = `Description will be truncated (${length}/${SEO_LIMITS.metaDescription.max})`;
+  } else if (length < SEO_LIMITS.metaDescription.min) {
+    status = "warning";
+    message = `Description is short (${length}/${SEO_LIMITS.metaDescription.min} min)`;
+  } else if (focusKeyphrase && !description.toLowerCase().includes(focusKeyphrase.toLowerCase())) {
+    status = "warning";
+    message = "Focus keyphrase not found in description";
+  }
+  return { field: "meta_description", value: description, length, limit: SEO_LIMITS.metaDescription, status, message };
+}
+function validateBlogPostSeo(post) {
+  const results = [];
+  const focusKeyphrase = post.focus_keyphrase;
+  if (post.meta_title || post.title) {
+    results.push(validateSeoTitle(post.meta_title || post.title || "", focusKeyphrase));
+  }
+  if (post.meta_description) {
+    results.push(validateMetaDescription(post.meta_description, focusKeyphrase));
+  }
+  if (post.title && focusKeyphrase) {
+    const titleLower = post.title.toLowerCase();
+    const keyLower = focusKeyphrase.toLowerCase();
+    if (!titleLower.includes(keyLower)) {
+      results.push({
+        field: "h1_alignment",
+        value: post.title,
+        length: post.title.length,
+        limit: { max: 100 },
+        status: "warning",
+        message: "H1 (title) should include the focus keyphrase"
+      });
+    }
+  }
+  if (post.word_count !== void 0) {
+    let wordStatus = "good";
+    let wordMessage = "Content length is optimal for SEO";
+    if (post.word_count < 600) {
+      wordStatus = "error";
+      wordMessage = `Content is thin (${post.word_count} words). Aim for 1200+ words.`;
+    } else if (post.word_count < 1200) {
+      wordStatus = "warning";
+      wordMessage = `Content is short (${post.word_count} words). Long-form (1200-2500) ranks better.`;
+    } else if (post.word_count > 2500) {
+      wordMessage = `Comprehensive content (${post.word_count} words). Consider splitting into a topic cluster.`;
+    }
+    results.push({
+      field: "word_count",
+      value: String(post.word_count),
+      length: post.word_count,
+      limit: { min: 1200, max: 2500, recommended: 1800 },
+      status: wordStatus,
+      message: wordMessage
+    });
+  }
+  return results;
+}
+async function getBlogPost(slug) {
+  const { apiUrl, apiKey } = getConfig();
+  if (!apiKey) {
+    console.warn("[Blog] No API key configured");
+    return null;
+  }
+  try {
+    const response = await fetch(`${apiUrl}/public/blog/posts/${slug}`, {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 60 }
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.post || null;
+  } catch (error) {
+    console.error("[Blog] Error fetching post:", error);
+    return null;
+  }
+}
+async function getAllBlogSlugs() {
+  const { apiUrl, apiKey } = getConfig();
+  if (!apiKey) {
+    console.warn("[Blog] No API key configured");
+    return [];
+  }
+  try {
+    const response = await fetch(`${apiUrl}/public/blog/slugs`, {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.slugs || [];
+  } catch (error) {
+    console.error("[Blog] Error fetching slugs:", error);
+    return [];
+  }
+}
+async function getBlogCategories() {
+  const { apiUrl, apiKey } = getConfig();
+  if (!apiKey) return [];
+  try {
+    const response = await fetch(`${apiUrl}/public/blog/categories`, {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.categories || [];
+  } catch (error) {
+    console.error("[Blog] Error fetching categories:", error);
+    return [];
+  }
+}
+async function generateBlogPostMetadata(slug, options = {}) {
+  const post = await getBlogPost(slug);
+  const { siteName, siteUrl = "", defaultImage, twitterHandle } = options;
+  if (!post) {
+    return {
+      title: "Post Not Found",
+      description: "The requested blog post could not be found."
+    };
+  }
+  const title = post.meta_title || post.title;
+  const description = post.meta_description || post.excerpt || "";
+  const image = post.og_image || post.featured_image || defaultImage;
+  const url = `${siteUrl}/blog/${post.slug}`;
+  return {
+    title,
+    description,
+    openGraph: {
+      title: post.og_title || title,
+      description: post.og_description || description,
+      url,
+      siteName,
+      type: "article",
+      publishedTime: post.published_at,
+      authors: post.author ? [typeof post.author === "string" ? post.author : post.author.name] : void 0,
+      images: image ? [
+        {
+          url: image,
+          width: post.featured_image_width || 1200,
+          height: post.featured_image_height || 630,
+          alt: post.featured_image_alt || post.title
+        }
+      ] : void 0
+    },
+    twitter: {
+      card: "summary_large_image",
+      title,
+      description,
+      images: image ? [image] : void 0,
+      creator: twitterHandle
+    },
+    alternates: {
+      canonical: post.canonical_url || url
+    },
+    other: {
+      "article:published_time": post.published_at || "",
+      "article:section": typeof post.category === "string" ? post.category : post.category?.name || ""
+    }
+  };
+}
+function generateBlogIndexMetadata(options) {
+  const {
+    title = "Blog",
+    description = "Read our latest articles and insights.",
+    siteName,
+    siteUrl = "",
+    defaultImage,
+    twitterHandle
+  } = options;
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      url: `${siteUrl}/blog`,
+      siteName,
+      type: "website",
+      images: defaultImage ? [{ url: defaultImage }] : void 0
+    },
+    twitter: {
+      card: "summary_large_image",
+      title,
+      description,
+      images: defaultImage ? [defaultImage] : void 0,
+      creator: twitterHandle
+    }
+  };
+}
+function generateBlogCategoryMetadata(categoryName, options = {}) {
+  const { siteName, siteUrl = "", defaultImage } = options;
+  const title = `${categoryName} - Blog`;
+  const description = `Browse all posts in ${categoryName}.`;
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      url: `${siteUrl}/blog/category/${categoryName.toLowerCase()}`,
+      siteName,
+      type: "website",
+      images: defaultImage ? [{ url: defaultImage }] : void 0
+    }
+  };
+}
+async function generateBlogStaticParams() {
+  const slugs = await getAllBlogSlugs();
+  return slugs.map((s) => ({ slug: s.slug }));
+}
+async function generateCategoryStaticParams() {
+  const categories = await getBlogCategories();
+  return categories.map((c) => ({ category: c.slug }));
+}
+async function generateBlogSitemap(siteUrl) {
+  const slugs = await getAllBlogSlugs();
+  const categories = await getBlogCategories();
+  const entries = [
+    // Blog index
+    {
+      url: `${siteUrl}/blog`,
+      changeFrequency: "daily",
+      priority: 0.8
+    }
+  ];
+  categories.forEach((cat) => {
+    entries.push({
+      url: `${siteUrl}/blog/category/${cat.slug}`,
+      changeFrequency: "weekly",
+      priority: 0.6
+    });
+  });
+  slugs.forEach((post) => {
+    entries.push({
+      url: `${siteUrl}/blog/${post.slug}`,
+      lastModified: post.last_modified ? new Date(post.last_modified) : void 0,
+      changeFrequency: "weekly",
+      priority: 0.7
+    });
+  });
+  return entries;
+}
+function generateBlogPostSchema(post, options = {}) {
+  const { siteUrl = "", siteName, logoUrl } = options;
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "BlogPosting",
+    headline: post.title,
+    description: post.excerpt || post.meta_description,
+    url: `${siteUrl}/blog/${post.slug}`,
+    datePublished: post.published_at,
+    dateModified: post.updated_at,
+    author: {
+      "@type": "Person",
+      name: typeof post.author === "string" ? post.author : post.author?.name
+    }
+  };
+  if (post.featured_image) {
+    schema.image = {
+      "@type": "ImageObject",
+      url: post.featured_image,
+      width: post.featured_image_width || 1200,
+      height: post.featured_image_height || 630
+    };
+  }
+  if (siteName || logoUrl) {
+    schema.publisher = {
+      "@type": "Organization",
+      name: siteName,
+      logo: logoUrl ? {
+        "@type": "ImageObject",
+        url: logoUrl
+      } : void 0
+    };
+  }
+  if (post.faq_items && Array.isArray(post.faq_items) && post.faq_items.length > 0) {
+    schema.mainEntity = {
+      "@type": "FAQPage",
+      mainEntity: post.faq_items.map((faq) => ({
+        "@type": "Question",
+        name: faq.question,
+        acceptedAnswer: {
+          "@type": "Answer",
+          text: faq.answer
+        }
+      }))
+    };
+  }
+  return schema;
+}
+function generateBlogListSchema(options = {}) {
+  const { siteUrl = "", siteName, description } = options;
+  return {
+    "@context": "https://schema.org",
+    "@type": "Blog",
+    name: siteName ? `${siteName} Blog` : "Blog",
+    description: description || "Our latest articles and insights.",
+    url: `${siteUrl}/blog`
+  };
+}
+function generateFaqSchema(faqItems) {
+  if (!faqItems || faqItems.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: faqItems.map((faq) => ({
+      "@type": "Question",
+      name: faq.question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: faq.answer
+      }
+    }))
+  };
+}
+function generateHowToSchema(post, steps, options = {}) {
+  const { siteUrl = "" } = options;
+  return {
+    "@context": "https://schema.org",
+    "@type": "HowTo",
+    name: post.title,
+    description: post.excerpt || post.meta_description,
+    image: post.featured_image,
+    totalTime: post.reading_time ? `PT${post.reading_time}M` : void 0,
+    step: steps.map((step, index) => ({
+      "@type": "HowToStep",
+      position: index + 1,
+      name: step.name,
+      text: step.text,
+      image: step.image,
+      url: step.url || `${siteUrl}/blog/${post.slug}#step-${index + 1}`
+    }))
+  };
+}
+async function getAllBlogPosts() {
+  const { apiUrl, apiKey } = getConfig();
+  if (!apiKey) {
+    console.warn("[Blog] No API key configured");
+    return [];
+  }
+  try {
+    const response = await fetch(`${apiUrl}/public/blog/posts?limit=100`, {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.posts || [];
+  } catch (error) {
+    console.error("[Blog] Error fetching posts for RSS:", error);
+    return [];
+  }
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").trim();
+}
+async function generateRssFeed(options) {
+  const {
+    siteUrl,
+    siteName,
+    description = "Latest blog posts and insights",
+    language = "en-us",
+    copyright,
+    managingEditor,
+    webMaster,
+    ttl = 60,
+    imageUrl
+  } = options;
+  const posts = await getAllBlogPosts();
+  const now = (/* @__PURE__ */ new Date()).toUTCString();
+  let rss = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
+  <channel>
+    <title>${escapeXml(siteName)}</title>
+    <link>${siteUrl}</link>
+    <description>${escapeXml(description)}</description>
+    <language>${language}</language>
+    <lastBuildDate>${now}</lastBuildDate>
+    <pubDate>${now}</pubDate>
+    <ttl>${ttl}</ttl>
+    <atom:link href="${siteUrl}/blog/rss.xml" rel="self" type="application/rss+xml"/>
+`;
+  if (copyright) {
+    rss += `    <copyright>${escapeXml(copyright)}</copyright>
+`;
+  }
+  if (managingEditor) {
+    rss += `    <managingEditor>${escapeXml(managingEditor)}</managingEditor>
+`;
+  }
+  if (webMaster) {
+    rss += `    <webMaster>${escapeXml(webMaster)}</webMaster>
+`;
+  }
+  if (imageUrl) {
+    rss += `    <image>
+      <url>${imageUrl}</url>
+      <title>${escapeXml(siteName)}</title>
+      <link>${siteUrl}</link>
+    </image>
+`;
+  }
+  for (const post of posts) {
+    const postUrl = `${siteUrl}/blog/${post.slug}`;
+    const pubDate = post.published_at ? new Date(post.published_at).toUTCString() : now;
+    const author = typeof post.author === "string" ? post.author : post.author?.name || "Unknown";
+    const fullContent = post.content_html || post.content || "";
+    const description2 = post.excerpt || stripHtml(fullContent).substring(0, 300) + "...";
+    rss += `    <item>
+      <title>${escapeXml(post.title)}</title>
+      <link>${postUrl}</link>
+      <guid isPermaLink="true">${postUrl}</guid>
+      <description>${escapeXml(description2)}</description>
+      <content:encoded><![CDATA[${fullContent}]]></content:encoded>
+      <pubDate>${pubDate}</pubDate>
+      <author>${escapeXml(author)}</author>
+`;
+    if (post.category) {
+      const categoryName = typeof post.category === "string" ? post.category : post.category.name;
+      rss += `      <category>${escapeXml(categoryName)}</category>
+`;
+    }
+    if (post.tags && Array.isArray(post.tags)) {
+      for (const tag of post.tags) {
+        const tagName = typeof tag === "string" ? tag : tag.name;
+        rss += `      <category>${escapeXml(tagName)}</category>
+`;
+      }
+    }
+    if (post.featured_image) {
+      rss += `      <enclosure url="${post.featured_image}" type="image/jpeg"/>
+`;
+    }
+    rss += `    </item>
+`;
+  }
+  rss += `  </channel>
+</rss>`;
+  return rss;
+}
+async function generateAtomFeed(options) {
+  const {
+    siteUrl,
+    siteName,
+    description = "Latest blog posts and insights",
+    managingEditor
+  } = options;
+  const posts = await getAllBlogPosts();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let atom = `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>${escapeXml(siteName)}</title>
+  <subtitle>${escapeXml(description)}</subtitle>
+  <link href="${siteUrl}/blog/feed.xml" rel="self"/>
+  <link href="${siteUrl}"/>
+  <id>${siteUrl}/blog</id>
+  <updated>${now}</updated>
+`;
+  if (managingEditor) {
+    atom += `  <author>
+    <name>${escapeXml(managingEditor)}</name>
+  </author>
+`;
+  }
+  for (const post of posts) {
+    const postUrl = `${siteUrl}/blog/${post.slug}`;
+    const updated = post.updated_at || post.published_at || now;
+    const published = post.published_at || now;
+    const author = typeof post.author === "string" ? post.author : post.author?.name || "Unknown";
+    const fullContent = post.content_html || post.content || "";
+    atom += `  <entry>
+    <title>${escapeXml(post.title)}</title>
+    <link href="${postUrl}"/>
+    <id>${postUrl}</id>
+    <updated>${new Date(updated).toISOString()}</updated>
+    <published>${new Date(published).toISOString()}</published>
+    <author>
+      <name>${escapeXml(author)}</name>
+    </author>
+    <summary>${escapeXml(post.excerpt || stripHtml(fullContent).substring(0, 300))}</summary>
+    <content type="html"><![CDATA[${fullContent}]]></content>
+  </entry>
+`;
+  }
+  atom += `</feed>`;
+  return atom;
+}
+async function getPostsByCategory(categorySlug) {
+  const { apiUrl, apiKey } = getConfig();
+  if (!apiKey) return [];
+  try {
+    const response = await fetch(`${apiUrl}/public/blog/posts?category=${categorySlug}&limit=50`, {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.posts || [];
+  } catch (error) {
+    console.error("[Blog] Error fetching category posts:", error);
+    return [];
+  }
+}
+async function identifyTopicClusters(categorySlug) {
+  const posts = await getPostsByCategory(categorySlug);
+  if (posts.length < 3) return null;
+  const sortedByLength = [...posts].sort((a, b) => (b.word_count || 0) - (a.word_count || 0));
+  const pillar = sortedByLength[0];
+  const supportingPosts = sortedByLength.slice(1);
+  const internalLinks = [];
+  for (const support of supportingPosts) {
+    internalLinks.push({
+      from: pillar.slug,
+      to: support.slug,
+      anchor: support.title
+    });
+  }
+  for (const support of supportingPosts) {
+    internalLinks.push({
+      from: support.slug,
+      to: pillar.slug,
+      anchor: pillar.title
+    });
+  }
+  return {
+    pillar,
+    supportingPosts,
+    internalLinks
+  };
+}
+async function getRelatedInsights(currentSlug, options = {}) {
+  const { apiUrl, apiKey } = getConfig();
+  const { limit = 3, category } = options;
+  if (!apiKey) return [];
+  try {
+    const response = await fetch(`${apiUrl}/public/blog/related`, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        slug: currentSlug,
+        limit,
+        category
+      }),
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.posts || [];
+  } catch (error) {
+    console.error("[Blog] Error fetching related posts:", error);
+    return [];
+  }
+}
+function generateBreadcrumbSchema(post, options = {}) {
+  const { siteUrl = "", siteName = "Home" } = options;
+  const items = [
+    {
+      "@type": "ListItem",
+      position: 1,
+      name: siteName,
+      item: siteUrl
+    },
+    {
+      "@type": "ListItem",
+      position: 2,
+      name: "Blog",
+      item: `${siteUrl}/blog`
+    }
+  ];
+  if (post.category) {
+    const categoryName = typeof post.category === "string" ? post.category : post.category.name;
+    const categorySlug = typeof post.category === "string" ? post.category.toLowerCase().replace(/\s+/g, "-") : post.category.slug;
+    items.push({
+      "@type": "ListItem",
+      position: 3,
+      name: categoryName,
+      item: `${siteUrl}/blog/category/${categorySlug}`
+    });
+    items.push({
+      "@type": "ListItem",
+      position: 4,
+      name: post.title,
+      item: `${siteUrl}/blog/${post.slug}`
+    });
+  } else {
+    items.push({
+      "@type": "ListItem",
+      position: 3,
+      name: post.title,
+      item: `${siteUrl}/blog/${post.slug}`
+    });
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items
+  };
+}
+function generateAllBlogSchemas(post, options = {}) {
+  const schemas = [];
+  const eeatSchema = post.schema;
+  if (eeatSchema) {
+    const arr = Array.isArray(eeatSchema) ? eeatSchema : [eeatSchema];
+    schemas.push(...arr);
+  } else {
+    schemas.push(generateBlogPostSchema(post, options));
+    const faqItems = post.faq_items ?? post.faqItems;
+    if (faqItems && faqItems.length > 0) {
+      const faqSchema = generateFaqSchema(faqItems);
+      if (faqSchema) schemas.push(faqSchema);
+    }
+  }
+  schemas.push(generateBreadcrumbSchema(post, options));
+  return schemas;
+}
+
+export { SEO_LIMITS, generateAllBlogSchemas, generateAtomFeed, generateBlogCategoryMetadata, generateBlogIndexMetadata, generateBlogListSchema, generateBlogPostMetadata, generateBlogPostSchema, generateBlogSitemap, generateBlogStaticParams, generateBreadcrumbSchema, generateCategoryStaticParams, generateFaqSchema, generateHowToSchema, generateRssFeed, getAllBlogPosts, getAllBlogSlugs, getBlogCategories, getBlogPost, getPostsByCategory, getRelatedInsights, identifyTopicClusters, validateBlogPostSeo, validateMetaDescription, validateSeoTitle };
+//# sourceMappingURL=server.mjs.map
+//# sourceMappingURL=server.mjs.map