@solutiondesk/blog 0.0.0 → 1.0.0-1cb60bf

package/dist/index.js

@@ -0,0 +1,434 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../sdk-core/src/http.ts
+var DEFAULT_BASE_URL = "https://api.solutiondesk.io";
+var SolutionDeskError = class extends Error {
+  constructor(message, init) {
+    super(message);
+    /** The HTTP status; `0` when no answer arrived (network error, aborted). */
+    __publicField(this, "status");
+    /** The parsed JSON body of the error answer (usually `{ error: string }`), else its text. */
+    __publicField(this, "body");
+    /** The requested URL. */
+    __publicField(this, "url");
+    /** Messages per input field on a `400` (e.g. `{ email: "Enter a valid email address." }`). */
+    __publicField(this, "fields");
+    this.name = "SolutionDeskError";
+    this.status = init.status;
+    this.body = init.body ?? null;
+    this.url = init.url;
+    this.fields = fieldsOf(init.body);
+    if (init.cause !== void 0) {
+      Object.defineProperty(this, "cause", { value: init.cause, enumerable: false });
+    }
+  }
+  /** `404`: unknown workspace, module turned off or unknown item — on purpose indistinguishable. */
+  get isNotFound() {
+    return this.status === 404;
+  }
+  /** `429`: over the rate limit; try again later. */
+  get isRateLimited() {
+    return this.status === 429;
+  }
+};
+function fieldsOf(body) {
+  if (!body || typeof body !== "object") return {};
+  const fields = body.fields;
+  if (!fields || typeof fields !== "object") return {};
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (typeof value === "string") out[key] = value;
+  }
+  return out;
+}
+function messageOf(body, status) {
+  if (body && typeof body === "object") {
+    const { error, message, statusCode } = body;
+    if (typeof statusCode === "number" && typeof message === "string" && message) return message;
+    if (typeof error === "string" && error) return error;
+    if (typeof message === "string" && message) return message;
+    if (Array.isArray(message) && typeof message[0] === "string") return message[0];
+  }
+  if (typeof body === "string" && body.trim() && body.length <= 300) return body.trim();
+  return `SolutionDesk answered ${status}.`;
+}
+function createMemoryEtagCache(maxEntries = 500) {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set(key, value) {
+      entries.delete(key);
+      entries.set(key, value);
+      if (entries.size > maxEntries) {
+        const oldest = entries.keys().next().value;
+        if (oldest !== void 0) entries.delete(oldest);
+      }
+    }
+  };
+}
+function queryString(query) {
+  if (!query) return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null || value === "") continue;
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return parts.length ? `?${parts.join("&")}` : "";
+}
+var seg = (value) => encodeURIComponent(String(value));
+function parseBody(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function createHttp(options = {}) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "").replace(/\/v1$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const cache = options.etagCache === true ? createMemoryEtagCache() : options.etagCache ? options.etagCache : void 0;
+  const url = (path, query) => `${baseUrl}/v1${path}${queryString(query)}`;
+  async function requestWithMeta(req) {
+    if (!fetchImpl) {
+      throw new Error("No global fetch available: pass `fetch` to the client.");
+    }
+    const target = url(req.path, req.query);
+    const headers = {
+      accept: req.accept ?? "application/json",
+      ...options.headers,
+      ...req.options?.headers
+    };
+    if (req.body !== void 0) headers["content-type"] = "application/json";
+    if (req.apiKey) headers.authorization = `Bearer ${req.apiKey}`;
+    const cacheKey = req.method === "GET" && !req.apiKey ? target : void 0;
+    const cached = cacheKey && cache ? cache.get(cacheKey) : void 0;
+    if (cached && !Object.keys(headers).some((h) => h.toLowerCase() === "if-none-match")) {
+      headers["if-none-match"] = cached.etag;
+    }
+    const init = {
+      ...req.options?.fetchOptions,
+      method: req.method,
+      headers
+    };
+    if (req.body !== void 0) init.body = JSON.stringify(req.body);
+    if (req.options?.signal !== void 0) init.signal = req.options.signal;
+    let response;
+    try {
+      response = await fetchImpl(target, init);
+    } catch (cause) {
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      throw new SolutionDeskError(`The request to SolutionDesk failed: ${reason}`, {
+        status: 0,
+        url: target,
+        cause
+      });
+    }
+    const finalUrl = response.url;
+    const meta = {
+      status: response.status,
+      finalUrl: typeof finalUrl === "string" && finalUrl ? finalUrl : null
+    };
+    if (response.status === 304 && cached) {
+      return { data: cached.body, ...meta };
+    }
+    const text = await response.text();
+    const body = response.ok && req.responseType === "text" ? text : parseBody(text);
+    if (!response.ok) {
+      throw new SolutionDeskError(messageOf(body, response.status), {
+        status: response.status,
+        body,
+        url: target
+      });
+    }
+    const etag = response.headers.get("etag");
+    if (cacheKey && cache && etag) cache.set(cacheKey, { etag, body });
+    return { data: body, ...meta };
+  }
+  return {
+    baseUrl,
+    url,
+    requestWithMeta,
+    request: async (req) => (await requestWithMeta(req)).data
+  };
+}
+function required(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError(`SolutionDesk: \`${name}\` is required.`);
+  }
+  return value;
+}
+
+// ../sdk-core/src/images.ts
+var IMAGE_WIDTHS = [320, 640, 960, 1280, 1920];
+function imageWidthFor(width) {
+  return IMAGE_WIDTHS.find((w) => w >= width) ?? 1920;
+}
+function imageUrl(url, width) {
+  if (width === void 0) return url;
+  const base = url.replace(/([?&])w=\d+(&|$)/, (_m, sep, end) => end ? sep : "");
+  const join = base.includes("?") ? /[?&]$/.test(base) ? "" : "&" : "?";
+  return `${base}${join}w=${imageWidthFor(width)}`;
+}
+
+// ../sdk-core/src/webhook.ts
+var SIGNATURE_HEADER = "x-solutiondesk-signature";
+var EVENT_HEADER = "x-solutiondesk-event";
+function encoder() {
+  const Encoder = globalThis.TextEncoder;
+  if (!Encoder) throw new Error("TextEncoder is not available in this runtime.");
+  return new Encoder();
+}
+function bytesOf(body) {
+  if (typeof body === "string") return encoder().encode(body);
+  return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function webhookBodyText(body) {
+  if (typeof body === "string") return body;
+  const Decoder = globalThis.TextDecoder;
+  if (!Decoder) throw new Error("TextDecoder is not available in this runtime.");
+  return new Decoder().decode(bytesOf(body));
+}
+function hex(buffer) {
+  let out = "";
+  for (const byte of new Uint8Array(buffer)) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function parseHeader(header) {
+  let t = Number.NaN;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const index = part.indexOf("=");
+    if (index < 0) continue;
+    const key = part.slice(0, index).trim();
+    const value = part.slice(index + 1).trim();
+    if (key === "t" && /^\d{1,12}$/.test(value)) t = Number(value);
+    else if (key === "v1" && /^[0-9a-f]{64}$/i.test(value)) signatures.push(value.toLowerCase());
+  }
+  return Number.isFinite(t) && signatures.length > 0 ? { t, signatures } : null;
+}
+async function verifyWebhookSignature(secret, rawBody, header, options = {}) {
+  if (!secret || !header || header.length > 1e3) return false;
+  const parsed = parseHeader(header);
+  if (!parsed) return false;
+  const now = options.now instanceof Date ? options.now.getTime() : options.now ?? Date.now();
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (Math.abs(now / 1e3 - parsed.t) > tolerance) return false;
+  const subtle = options.crypto?.subtle ?? globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "Web Crypto is not available: pass `crypto` (on Node 18: require('node:crypto').webcrypto)."
+    );
+  }
+  const text = encoder();
+  const key = await subtle.importKey(
+    "raw",
+    text.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const prefix = text.encode(`${parsed.t}.`);
+  const body = bytesOf(rawBody);
+  const signed = new Uint8Array(prefix.length + body.length);
+  signed.set(prefix, 0);
+  signed.set(body, prefix.length);
+  const expected = hex(await subtle.sign("HMAC", key, signed));
+  let ok = false;
+  for (const signature of parsed.signatures) ok = constantTimeEqual(expected, signature) || ok;
+  return ok;
+}
+async function parseWebhook(secret, rawBody, header, options = {}) {
+  if (!await verifyWebhookSignature(secret, rawBody, header, options)) return null;
+  try {
+    return JSON.parse(webhookBodyText(rawBody));
+  } catch {
+    return null;
+  }
+}
+
+// src/blocks.ts
+function escapeBlogHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function unescapeAttribute(value) {
+  return value.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+var OPEN = /<(span|div) class="sd-block" data-block="([^"]*)" data-props="([^"]*)">/g;
+function closingEnd(html, tag, from) {
+  const pattern = new RegExp(`<${tag}[\\s>]|</${tag}>`, "g");
+  pattern.lastIndex = from;
+  let depth = 1;
+  for (let match = pattern.exec(html); match; match = pattern.exec(html)) {
+    depth += match[0].startsWith("</") ? -1 : 1;
+    if (depth === 0) return match.index + match[0].length;
+  }
+  return html.length;
+}
+function parseProps(raw) {
+  try {
+    const parsed = JSON.parse(unescapeAttribute(raw));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const props = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string" || typeof value === "boolean") props[key] = value;
+    }
+    return props;
+  } catch {
+    return {};
+  }
+}
+function renderBlogBlocks(html, renderers) {
+  let out = "";
+  let pos = 0;
+  OPEN.lastIndex = 0;
+  for (let open = OPEN.exec(html); open; open = OPEN.exec(html)) {
+    const [whole, tag = "div", name = "", rawProps = ""] = open;
+    const start = open.index;
+    const contentStart = start + whole.length;
+    const end = closingEnd(html, tag, contentStart);
+    const inner = html.slice(contentStart, end - `</${tag}>`.length);
+    const body = /^(?:<p class="sd-block-text">([\s\S]*?)<\/p>)?<div class="sd-block-body">([\s\S]*)<\/div>$/.exec(
+      inner
+    );
+    const element = {
+      block: unescapeAttribute(name),
+      props: parseProps(rawProps),
+      inline: tag === "span",
+      textHtml: body ? body[1] ?? "" : inner,
+      childrenHtml: body ? renderBlogBlocks(body[2] ?? "", renderers) : null
+    };
+    const own = renderers[element.block]?.(element);
+    out += html.slice(pos, start);
+    if (own !== void 0) out += own;
+    else if (body) {
+      out += `${whole}${body[1] !== void 0 ? `<p class="sd-block-text">${body[1]}</p>` : ""}<div class="sd-block-body">${element.childrenHtml}</div></${tag}>`;
+    } else out += html.slice(start, end);
+    pos = end;
+    OPEN.lastIndex = end;
+  }
+  return out + html.slice(pos);
+}
+
+// src/client.ts
+function createBlogClient(options) {
+  const workspace = required(options.workspace, "workspace");
+  const http = createHttp(options);
+  const base = `/blog/${seg(workspace)}`;
+  const langOf = (params) => params?.lang ?? options.lang;
+  const listPosts = (params = {}, requestOptions) => http.request({
+    method: "GET",
+    path: `${base}/posts`,
+    query: {
+      lang: langOf(params),
+      tag: params.tag,
+      author: params.author,
+      limit: params.limit,
+      cursor: params.cursor
+    },
+    options: requestOptions
+  });
+  const fetchPost = (slug, lang, requestOptions) => http.request({
+    method: "GET",
+    path: `${base}/posts/${seg(slug)}`,
+    query: { lang },
+    options: requestOptions
+  });
+  async function getPost(slug, params = {}, requestOptions) {
+    required(slug, "slug");
+    const lang = langOf(params);
+    const asked = slug.toLowerCase();
+    if (params.redirect === "manual") {
+      try {
+        return await fetchPost(slug, lang, {
+          ...requestOptions,
+          fetchOptions: { ...requestOptions?.fetchOptions, redirect: "manual" }
+        });
+      } catch (error) {
+        if (!(error instanceof SolutionDeskError)) throw error;
+        const redirectTo = error.body?.redirectTo;
+        if (error.status === 301 && typeof redirectTo === "string") return { redirectTo };
+        if (error.status !== 0) throw error;
+      }
+      const payload2 = await fetchPost(slug, lang, requestOptions);
+      return payload2.post.slug !== asked ? { redirectTo: payload2.post.slug } : payload2;
+    }
+    const payload = await fetchPost(slug, lang, requestOptions);
+    return { ...payload, movedFrom: payload.post.slug !== asked ? slug : null };
+  }
+  return {
+    workspace,
+    listPosts,
+    async *allPosts(params = {}, requestOptions) {
+      let cursor = null;
+      do {
+        const page = await listPosts(
+          { ...params, limit: params.limit ?? 50, cursor },
+          requestOptions
+        );
+        yield* page.posts;
+        cursor = page.nextCursor;
+      } while (cursor);
+    },
+    getPost,
+    listTags: async (params, requestOptions) => http.request({
+      method: "GET",
+      path: `${base}/tags`,
+      query: { lang: langOf(params) },
+      options: requestOptions
+    }),
+    listAuthors: async (params, requestOptions) => http.request({
+      method: "GET",
+      path: `${base}/authors`,
+      query: { lang: langOf(params) },
+      options: requestOptions
+    }),
+    getPreview: async (token, params, requestOptions) => http.request({
+      method: "GET",
+      path: `${base}/preview`,
+      query: { token: required(token, "token"), lang: langOf(params) },
+      options: requestOptions
+    }),
+    imageUrl
+  };
+}
+function parseBlogWebhook(secret, rawBody, signatureHeader, options) {
+  return parseWebhook(secret, rawBody, signatureHeader, options);
+}
+
+// src/head.ts
+function renderBlogJsonLd(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+function renderBlogHead(post) {
+  const { seo } = post;
+  const lines = [`<title>${escapeBlogHtml(seo.title)}</title>`];
+  if (seo.canonicalUrl) {
+    lines.push(`<link rel="canonical" href="${escapeBlogHtml(seo.canonicalUrl)}">`);
+  }
+  for (const alternate of seo.alternates) {
+    lines.push(
+      `<link rel="alternate" hreflang="${escapeBlogHtml(alternate.locale)}" href="${escapeBlogHtml(alternate.url)}">`
+    );
+  }
+  for (const tag of seo.meta) {
+    const [attribute, key] = "property" in tag ? ["property", tag.property] : ["name", tag.name];
+    lines.push(
+      `<meta ${attribute}="${escapeBlogHtml(key)}" content="${escapeBlogHtml(tag.content)}">`
+    );
+  }
+  for (const data of seo.jsonLd) {
+    lines.push(`<script type="application/ld+json">${renderBlogJsonLd(data)}</script>`);
+  }
+  return lines.join("\n");
+}
+
+export { DEFAULT_BASE_URL, EVENT_HEADER, IMAGE_WIDTHS, SIGNATURE_HEADER, SolutionDeskError, createBlogClient, createMemoryEtagCache, escapeBlogHtml, imageUrl, imageWidthFor, parseBlogWebhook, renderBlogBlocks, renderBlogHead, renderBlogJsonLd, verifyWebhookSignature };

package/package.json

@@ -1,10 +1,58 @@
 {
   "name": "@solutiondesk/blog",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @solutiondesk/blog",
+  "version": "1.0.0-1cb60bf",
+  "description": "Typed, zero-dependency client for the SolutionDesk public blog API: posts, tags, authors, previews and webhook verification.",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "solutiondesk",
+    "blog",
+    "cms",
+    "headless-cms",
+    "sdk",
+    "typescript"
+  ],
+  "homepage": "https://help.solutiondesk.io/docs/team/blog-website",
+  "bugs": {
+    "url": "https://github.com/wemogy/solutiondesk/issues"
+  },
+  "license": "MIT",
+  "author": "wemogy IT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wemogy/solutiondesk.git",
+    "directory": "packages/sdk-blog"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}