@autoblogwriter/sdk 1.0.2 → 2.0.0

package/dist/next.cjs

@@ -0,0 +1,712 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createEnvAnalyticsHandler: () => createEnvAnalyticsHandler,
+  createEnvRevalidateHandler: () => createEnvRevalidateHandler,
+  fetchBlogPost: () => fetchBlogPost,
+  fetchBlogPosts: () => fetchBlogPosts,
+  generateBlogRobots: () => generateBlogRobots,
+  generateBlogSitemap: () => generateBlogSitemap,
+  generatePostMetadata: () => generatePostMetadata
+});
+module.exports = __toCommonJS(next_exports);
+
+// src/auth.ts
+function buildAuthHeaders(apiKey, authMode = "bearer") {
+  if (authMode === "x-api-key") {
+    return { "x-api-key": apiKey };
+  }
+  return { Authorization: `Bearer ${apiKey}` };
+}
+
+// src/errors.ts
+var BlogAutoError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = new.target.name;
+    this.causeError = options?.cause;
+  }
+};
+var ConfigError = class extends BlogAutoError {
+};
+var ApiError = class extends BlogAutoError {
+  constructor(message, info, options) {
+    super(message, options);
+    this.status = info.status;
+    this.code = info.code;
+    this.details = info.details;
+  }
+};
+
+// src/utils.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+function normalizeApiUrl(apiUrl) {
+  if (!apiUrl) {
+    throw new ConfigError("apiUrl is required");
+  }
+  return apiUrl.replace(/\/$/, "");
+}
+function resolveClientConfig(config) {
+  if (!config) {
+    throw new ConfigError("Client configuration is required");
+  }
+  const apiKey = config.apiKey?.trim();
+  if (!apiKey) {
+    throw new ConfigError("apiKey is required to authenticate with BlogAuto");
+  }
+  if (!config.workspaceId && !config.workspaceSlug) {
+    throw new ConfigError("Provide either workspaceId or workspaceSlug");
+  }
+  const authMode = config.authMode ?? "bearer";
+  return {
+    apiKey,
+    apiUrl: normalizeApiUrl(config.apiUrl),
+    workspaceId: config.workspaceId,
+    workspaceSlug: config.workspaceSlug,
+    authMode,
+    fetch: config.fetch ?? globalThis.fetch.bind(globalThis),
+    headers: { ...config.headers ?? {} },
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  };
+}
+function buildQuery(params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null || value === "") {
+      return;
+    }
+    query.set(key, String(value));
+  });
+  const qs = query.toString();
+  return qs ? `?${qs}` : "";
+}
+async function withTimeout(promise, timeoutMs) {
+  if (!timeoutMs) {
+    return promise;
+  }
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(
+        new ApiError(`Request timed out after ${timeoutMs}ms`, {
+          status: 408
+        })
+      );
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function mergeHeaders(...headerObjects) {
+  return headerObjects.reduce((acc, headers) => {
+    if (!headers) {
+      return acc;
+    }
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value === void 0 || value === null) {
+        return;
+      }
+      acc[key.toLowerCase()] = value;
+    });
+    return acc;
+  }, {});
+}
+
+// src/client.ts
+function createBlogAutoClient(config) {
+  const resolved = resolveClientConfig(config);
+  const fetchImpl = resolved.fetch;
+  const debug = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.BLOGAUTO_DEBUG === "true";
+  const debugLog = (...args) => {
+    if (debug) {
+      console.log("[blogauto]", ...args);
+    }
+  };
+  function ensureWorkspaceSlug() {
+    if (!resolved.workspaceSlug) {
+      throw new ConfigError("workspaceSlug is required to call the BlogAuto public API");
+    }
+    return resolved.workspaceSlug;
+  }
+  function buildUrl(path, query) {
+    const qs = buildQuery(query ?? {});
+    return `${resolved.apiUrl}${path}${qs}`;
+  }
+  function unwrapSuccessPayload(payload) {
+    if (payload && typeof payload === "object") {
+      const maybePayload = payload;
+      if ("success" in maybePayload) {
+        if (maybePayload.success === false) {
+          throw new ApiError(
+            maybePayload.error?.message ?? "BlogAuto request failed",
+            { status: 500, details: maybePayload }
+          );
+        }
+        if (maybePayload.success && "data" in maybePayload) {
+          return maybePayload.data;
+        }
+      }
+    }
+    return payload;
+  }
+  async function request(opts) {
+    const method = opts.method ?? "GET";
+    const url = buildUrl(opts.path, opts.query);
+    const authHeaders = buildAuthHeaders(resolved.apiKey, resolved.authMode);
+    const baseHeaders = mergeHeaders(resolved.headers, authHeaders, opts.headers);
+    const init = {
+      method,
+      headers: baseHeaders
+    };
+    if (opts.body) {
+      init.body = typeof opts.body === "string" ? opts.body : JSON.stringify(opts.body);
+      init.headers = {
+        ...baseHeaders,
+        "content-type": baseHeaders["content-type"] ?? "application/json"
+      };
+    }
+    if (opts.cache !== void 0) {
+      init.cache = opts.cache;
+    }
+    if (opts.next) {
+      init.next = opts.next;
+    }
+    const startedAt = Date.now();
+    try {
+      const response = await withTimeout(fetchImpl(url, init), resolved.timeoutMs);
+      debugLog("response", {
+        method,
+        url,
+        status: response.status,
+        durationMs: Date.now() - startedAt
+      });
+      if (opts.allowNotFound && response.status === 404) {
+        return null;
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const isJson = contentType.includes("application/json");
+      const payload = isJson ? await response.json().catch(() => void 0) : await response.text();
+      if (!response.ok) {
+        if (response.status === 404 && opts.allowNotFound) {
+          return null;
+        }
+        const errorBody = payload;
+        const message = errorBody?.error?.message ?? errorBody?.message ?? `Request failed with status ${response.status}`;
+        throw new ApiError(message, {
+          status: response.status,
+          code: errorBody?.error?.code ?? errorBody?.code,
+          details: errorBody?.error?.details ?? errorBody
+        });
+      }
+      if (isJson) {
+        return unwrapSuccessPayload(payload);
+      }
+      return payload ?? void 0;
+    } catch (error) {
+      debugLog("request failed", {
+        method,
+        url,
+        durationMs: Date.now() - startedAt,
+        error: error instanceof Error ? error.message : error
+      });
+      if (error instanceof BlogAutoError) {
+        throw error;
+      }
+      const causeMessage = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
+      const message = causeMessage ? `Network request to BlogAuto failed: ${causeMessage}` : "Network request to BlogAuto failed";
+      throw new ApiError(
+        message,
+        {
+          status: 0,
+          details: { url, method }
+        },
+        { cause: error }
+      );
+    }
+  }
+  async function fetchBlogPage(limit, page, cacheOptions) {
+    const workspaceSlug = ensureWorkspaceSlug();
+    debugLog("fetch posts page", { workspaceSlug, limit, page });
+    return request({
+      path: `/v1/public/${encodeURIComponent(workspaceSlug)}/blogs`,
+      query: { limit, page },
+      cache: cacheOptions?.cache,
+      next: cacheOptions?.next
+    });
+  }
+  return {
+    async getPosts(params) {
+      const limit = params?.limit ?? 20;
+      const cursorPage = params?.cursor ? Number(params.cursor) : void 0;
+      const page = Number.isFinite(cursorPage) && cursorPage >= 1 ? cursorPage : 1;
+      const data = await fetchBlogPage(limit, page, params);
+      return {
+        posts: data.items,
+        nextCursor: data.pagination.hasMore ? String(data.pagination.page + 1) : void 0
+      };
+    },
+    async getPostBySlug(slug, options) {
+      if (!slug) {
+        throw new ApiError("slug is required", { status: 400 });
+      }
+      const workspaceSlug = ensureWorkspaceSlug();
+      const post = await request({
+        path: `/v1/public/${encodeURIComponent(workspaceSlug)}/blogs/${encodeURIComponent(slug)}`,
+        allowNotFound: true,
+        cache: options?.cache,
+        next: options?.next
+      });
+      if (post === null) {
+        return null;
+      }
+      return post.post;
+    },
+    async getSitemapEntries() {
+      const entries = [];
+      const limit = 100;
+      let page = 1;
+      while (true) {
+        const pageData = await fetchBlogPage(limit, page);
+        pageData.items.forEach((post) => {
+          entries.push({ slug: post.slug, updatedAt: post.updatedAt });
+        });
+        if (!pageData.pagination.hasMore) {
+          break;
+        }
+        page = pageData.pagination.page + 1;
+      }
+      return entries;
+    }
+  };
+}
+
+// src/env.ts
+var _instance = null;
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+function createBlogAutoFromEnv() {
+  if (_instance) {
+    return _instance;
+  }
+  const apiUrl = process.env.BLOGAUTO_API_URL ?? "https://api.blogauto.io";
+  const apiKey = requireEnv("BLOGAUTO_API_KEY");
+  const workspaceSlug = requireEnv("BLOGAUTO_WORKSPACE_SLUG");
+  const workspaceId = process.env.BLOGAUTO_WORKSPACE_ID;
+  const siteUrl = process.env.SITE_URL ?? process.env.NEXT_PUBLIC_SITE_URL ?? "http://localhost:3000";
+  const revalidateSecret = process.env.BLOGAUTO_REVALIDATE_SECRET;
+  const analyticsToken = process.env.NEXT_PUBLIC_ANALYTICS_TOKEN;
+  const analyticsProxy = process.env.NEXT_PUBLIC_ANALYTICS_PROXY ?? "/api/blogauto/analytics";
+  const client = createBlogAutoClient({
+    apiUrl,
+    apiKey,
+    workspaceSlug,
+    workspaceId
+  });
+  _instance = {
+    client,
+    workspaceSlug,
+    workspaceId,
+    siteUrl,
+    revalidateSecret,
+    analyticsToken,
+    analyticsProxy,
+    apiUrl,
+    apiKey,
+    tags: {
+      posts: `blogauto:${workspaceSlug}:posts`,
+      post: (slug) => `blogauto:${workspaceSlug}:post:${slug}`,
+      sitemap: `blogauto:${workspaceSlug}:sitemap`
+    }
+  };
+  return _instance;
+}
+
+// src/metadata.ts
+function buildNextMetadata(post) {
+  const title = post.seo?.title ?? post.title;
+  const description = post.seo?.description ?? post.excerpt;
+  const keywords = post.seo?.keywords;
+  const canonical = post.metadata?.canonicalUrl;
+  const ogImageUrl = post.metadata?.ogImageUrl;
+  const metadata = {
+    title,
+    description
+  };
+  if (keywords && keywords.length > 0) {
+    metadata.keywords = keywords;
+  }
+  if (canonical) {
+    metadata.alternates = { canonical };
+  }
+  metadata.openGraph = {
+    type: "article",
+    title,
+    description,
+    publishedTime: post.publishedAt,
+    modifiedTime: post.updatedAt
+  };
+  if (ogImageUrl) {
+    metadata.openGraph.images = [{ url: ogImageUrl }];
+  }
+  metadata.twitter = {
+    card: ogImageUrl ? "summary_large_image" : "summary",
+    title,
+    description
+  };
+  if (ogImageUrl) {
+    metadata.twitter.images = [ogImageUrl];
+  }
+  return metadata;
+}
+
+// src/sitemap.ts
+function normalizeSiteUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function normalizeRoutePrefix(routePrefix) {
+  if (!routePrefix || routePrefix === "/") {
+    return "";
+  }
+  const withSlash = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
+  return withSlash.endsWith("/") ? withSlash.slice(0, -1) : withSlash;
+}
+function normalizeSlug(slug) {
+  return slug.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function buildSitemap(opts) {
+  const siteUrl = normalizeSiteUrl(opts.siteUrl);
+  const prefix = normalizeRoutePrefix(opts.routePrefix ?? "/blog");
+  const entries = opts.entries.map((entry) => {
+    const slug = normalizeSlug(entry.slug);
+    const hasSlug = slug.length > 0;
+    const slugFragment = hasSlug ? `/${slug}` : "";
+    const path = prefix ? `${prefix}${slugFragment}` : hasSlug ? `/${slug}` : "/";
+    return {
+      url: `${siteUrl}${path}`,
+      lastModified: entry.updatedAt
+    };
+  });
+  return entries;
+}
+
+// src/robots.ts
+function normalizeSiteUrl2(url) {
+  return url.replace(/\/$/, "");
+}
+function normalizePath(path) {
+  if (!path) {
+    return "/sitemap.xml";
+  }
+  if (!path.startsWith("/")) {
+    return `/${path}`;
+  }
+  return path;
+}
+function buildRobots(opts) {
+  const siteUrl = normalizeSiteUrl2(opts.siteUrl);
+  const sitemapPath = normalizePath(opts.sitemapPath ?? "/sitemap.xml");
+  const sitemapUrl = `${siteUrl}${sitemapPath}`;
+  return {
+    rules: [{ userAgent: "*", allow: "/" }],
+    sitemap: sitemapUrl
+  };
+}
+
+// src/next/helpers.ts
+async function fetchBlogPosts(options) {
+  const { client, tags } = createBlogAutoFromEnv();
+  return client.getPosts({
+    limit: options?.limit,
+    cursor: options?.cursor,
+    next: { tags: [tags.posts] }
+  });
+}
+async function fetchBlogPost(slug) {
+  const { client, tags } = createBlogAutoFromEnv();
+  const post = await client.getPostBySlug(slug, {
+    next: { tags: [tags.post(slug)] }
+  });
+  if (!post) {
+    const nav = await import(
+      /* webpackIgnore: true */
+      "next/navigation"
+    );
+    nav.notFound();
+    throw new Error("notFound");
+  }
+  return post;
+}
+async function generatePostMetadata(slug) {
+  const { client, tags } = createBlogAutoFromEnv();
+  const post = await client.getPostBySlug(slug, {
+    next: { tags: [tags.post(slug)] }
+  });
+  if (!post) {
+    return {};
+  }
+  return buildNextMetadata(post);
+}
+async function generateBlogSitemap() {
+  const { client, siteUrl } = createBlogAutoFromEnv();
+  const entries = await client.getSitemapEntries();
+  return buildSitemap({ siteUrl, routePrefix: "/blog", entries });
+}
+function generateBlogRobots() {
+  const { siteUrl } = createBlogAutoFromEnv();
+  return buildRobots({ siteUrl, sitemapPath: "/sitemap.xml" });
+}
+
+// src/revalidate.ts
+var import_crypto = __toESM(require("crypto"), 1);
+function jsonResponse(body, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("content-type", "application/json");
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers
+  });
+}
+function normalizeSignature(signature) {
+  if (!signature) {
+    return null;
+  }
+  const trimmed = signature.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const withoutPrefix = trimmed.startsWith("sha256=") ? trimmed.slice(7) : trimmed;
+  if (!withoutPrefix) {
+    return null;
+  }
+  try {
+    return Buffer.from(withoutPrefix, "hex");
+  } catch {
+    return null;
+  }
+}
+function verifyWebhookSignature(opts) {
+  const { rawBody, signature, secret } = opts;
+  if (!secret) {
+    throw new Error("Secret is required to verify webhook signatures");
+  }
+  const providedSignature = normalizeSignature(signature);
+  if (!providedSignature) {
+    return false;
+  }
+  const bodyBuffer = typeof rawBody === "string" ? Buffer.from(rawBody) : rawBody;
+  const expected = import_crypto.default.createHmac("sha256", secret).update(bodyBuffer).digest();
+  if (providedSignature.length !== expected.length) {
+    return false;
+  }
+  return import_crypto.default.timingSafeEqual(providedSignature, expected);
+}
+function defaultPaths(payload) {
+  const paths = /* @__PURE__ */ new Set(["/sitemap.xml", "/robots.txt", "/blog"]);
+  if (payload.postSlug) {
+    paths.add(`/blog/${payload.postSlug}`);
+  }
+  return Array.from(paths);
+}
+function defaultTags(payload) {
+  const tags = /* @__PURE__ */ new Set();
+  if (payload.workspaceSlug) {
+    tags.add(`blogauto:${payload.workspaceSlug}:sitemap`);
+    tags.add(`blogauto:${payload.workspaceSlug}:posts`);
+    if (payload.postSlug) {
+      tags.add(`blogauto:${payload.workspaceSlug}:post:${payload.postSlug}`);
+    }
+  }
+  return Array.from(tags);
+}
+function dedupe(values) {
+  if (!values || values.length === 0) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim())
+    )
+  );
+}
+function determineRouteType(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".xml") || lower.endsWith(".txt")) {
+    return "route";
+  }
+  return "page";
+}
+function createRevalidateRouteHandler(options) {
+  if (!options.secret) {
+    throw new Error("secret is required for createRevalidateRouteHandler");
+  }
+  const allowedSkewMs = Math.max(1, options.allowedSkewSeconds ?? 300) * 1e3;
+  const pathBuilder = options.revalidatePaths ?? defaultPaths;
+  const tagBuilder = options.revalidateTags ?? defaultTags;
+  return async function blogAutoRevalidateHandler(request) {
+    const signature = request.headers.get("x-blogauto-signature");
+    const receivedAt = Date.now();
+    const rawBody = await request.text();
+    const isValid = verifyWebhookSignature({
+      rawBody,
+      signature,
+      secret: options.secret
+    });
+    if (!isValid) {
+      return jsonResponse({ error: "Invalid webhook signature" }, { status: 401 });
+    }
+    let payload;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      return jsonResponse({ error: "Invalid JSON payload" }, { status: 400 });
+    }
+    if (!payload.workspaceSlug || typeof payload.workspaceSlug !== "string") {
+      return jsonResponse({ error: "workspaceSlug is required" }, { status: 400 });
+    }
+    if (!payload.ts || typeof payload.ts !== "string") {
+      return jsonResponse({ error: "Timestamp is required" }, { status: 400 });
+    }
+    const payloadTs = Date.parse(payload.ts);
+    if (Number.isNaN(payloadTs)) {
+      return jsonResponse({ error: "Invalid timestamp" }, { status: 400 });
+    }
+    if (Math.abs(receivedAt - payloadTs) > allowedSkewMs) {
+      return jsonResponse({ error: "Webhook timestamp is outside allowed skew" }, { status: 409 });
+    }
+    const paths = dedupe(pathBuilder(payload));
+    const tags = dedupe(tagBuilder(payload));
+    try {
+      if (options.revalidatePath && paths.length > 0) {
+        await Promise.all(
+          paths.map((path) => options.revalidatePath(path, determineRouteType(path)))
+        );
+      }
+      if (options.revalidateTag && tags.length > 0) {
+        await Promise.all(tags.map((tag) => options.revalidateTag(tag)));
+      }
+    } catch (error) {
+      return jsonResponse(
+        { error: "Failed to revalidate cache", details: error.message },
+        { status: 500 }
+      );
+    }
+    return jsonResponse({
+      ok: true,
+      event: payload.event ?? "post.published",
+      revalidated: {
+        paths,
+        tags
+      }
+    });
+  };
+}
+
+// src/next/route-handlers.ts
+function createEnvRevalidateHandler() {
+  return async (request) => {
+    const { revalidateSecret } = createBlogAutoFromEnv();
+    if (!revalidateSecret) {
+      return new Response(
+        JSON.stringify({ error: "Missing BLOGAUTO_REVALIDATE_SECRET" }),
+        { status: 500, headers: { "content-type": "application/json" } }
+      );
+    }
+    const nextCache = await import(
+      /* webpackIgnore: true */
+      "next/cache"
+    );
+    const { revalidatePath, revalidateTag } = nextCache;
+    const handler = createRevalidateRouteHandler({
+      secret: revalidateSecret,
+      revalidatePath,
+      revalidateTag
+    });
+    return handler(request);
+  };
+}
+function createEnvAnalyticsHandler() {
+  return async (request) => {
+    const { analyticsToken, apiUrl, apiKey, workspaceId, workspaceSlug } = createBlogAutoFromEnv();
+    if (!analyticsToken) {
+      return new Response(
+        JSON.stringify({ error: "Analytics proxy disabled" }),
+        { status: 503, headers: { "content-type": "application/json" } }
+      );
+    }
+    const provided = request.headers.get("x-api-key");
+    if (provided !== analyticsToken) {
+      return new Response(
+        JSON.stringify({ error: "Unauthorized" }),
+        { status: 401, headers: { "content-type": "application/json" } }
+      );
+    }
+    const payload = await request.json();
+    const envelope = {
+      ...payload,
+      workspaceId: workspaceId ?? payload.workspaceId,
+      workspaceSlug: workspaceSlug ?? payload.workspaceSlug
+    };
+    const response = await fetch(`${apiUrl}/v1/analytics/ingest`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...buildAuthHeaders(apiKey, "bearer")
+      },
+      body: JSON.stringify(envelope)
+    });
+    const text = await response.text();
+    const contentType = response.headers.get("content-type") ?? "application/json";
+    return new Response(text || "{}", {
+      status: response.status,
+      headers: { "content-type": contentType }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEnvAnalyticsHandler,
+  createEnvRevalidateHandler,
+  fetchBlogPost,
+  fetchBlogPosts,
+  generateBlogRobots,
+  generateBlogSitemap,
+  generatePostMetadata
+});
+//# sourceMappingURL=next.cjs.map