@zzclub/pipeline 0.3.0 → 0.4.0

package/src/providers/index.ts

@@ -0,0 +1,185 @@
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { PipelineConfig, ResolvedWorkspacePaths } from "../config";
+import { PublishResult, RenderAsset, RoutePrimary, WorkflowState } from "../state";
+import {
+  injectIllustrationImages,
+  prepareBodyForNewspic,
+} from "../text";
+import { resolveMarkdownRenderer } from "../adapter-loader";
+import { createWechatDraft, createWechatNewspic, extractImageUrls, mergePhotoLists } from "./wechat";
+
+export interface PublishRouteContext {
+  state: WorkflowState;
+  dryRun: boolean;
+  config: PipelineConfig;
+  workspacePaths: ResolvedWorkspacePaths;
+}
+
+export type PublishProvider = (ctx: PublishRouteContext) => Promise<PublishResult>;
+
+async function publishWechatArticleRoute({
+  state,
+  dryRun,
+  config,
+  workspacePaths,
+}: PublishRouteContext): Promise<PublishResult> {
+  const postPath = join(state.asset_path, "post.md");
+  let exportPostPath = postPath;
+  const cover = (state.images.render_assets as RenderAsset[]).find(
+    (asset) => asset.route === "wechat-article" && asset.kind === "cover",
+  );
+
+  const photos: string[] = [];
+  if (cover) {
+    photos.push(cover.path);
+  }
+  if (
+    state.images.body_inputs.scope === "article" &&
+    state.images.body_inputs.status === "ready"
+  ) {
+    const postContent = await readFile(postPath, "utf-8");
+    const draftContent = injectIllustrationImages(
+      postContent,
+      state.images.body_inputs.received,
+    );
+    exportPostPath = join(state.asset_path, "post-wechat-draft.md");
+    await writeFile(exportPostPath, draftContent, "utf-8");
+
+    for (const img of state.images.body_inputs.received) {
+      photos.push(img.path);
+    }
+  }
+
+  if (dryRun) {
+    console.error(`[dry-run] Zotepad export: ${exportPostPath}`);
+    console.error(`[dry-run] Wechat draft: ${state.metadata.title}`);
+    return {
+      route: "wechat-article",
+      status: "skipped",
+      detail: "dry-run",
+      published_at: null,
+      content_version: state.artifacts.content_version,
+      render_version: state.artifacts.render_version,
+    };
+  }
+
+  try {
+    const markdownRenderer = await resolveMarkdownRenderer(config);
+    const wxAccount = config.wx.accounts[state.route.account] ?? config.wx.accounts[config.wx.defaultAccount];
+    const { html } = await markdownRenderer.render({
+      markdownPath: exportPostPath,
+      outPath: workspacePaths.zotepadExportHtml,
+      account: state.route.account,
+      title: state.metadata.title,
+      customCss: wxAccount?.customCss ?? null,
+    });
+    await createWechatDraft({
+      account: state.route.account,
+      title: state.metadata.title,
+      html,
+      photos,
+      config,
+    });
+  } catch (error) {
+    return {
+      route: "wechat-article",
+      status: "failed",
+      detail: error instanceof Error ? error.message : String(error),
+      published_at: null,
+      content_version: state.artifacts.content_version,
+      render_version: state.artifacts.render_version,
+    };
+  }
+
+  return {
+    route: "wechat-article",
+    status: "success",
+    detail: null,
+    published_at: new Date().toISOString(),
+    content_version: state.artifacts.content_version,
+    render_version: state.artifacts.render_version,
+  };
+}
+
+async function publishWechatNewspicRoute({
+  state,
+  dryRun,
+  config,
+}: PublishRouteContext): Promise<PublishResult> {
+  const postPath = join(state.asset_path, "post.md");
+  const postContent = await readFile(postPath, "utf-8");
+  const bodyImageUrls = extractImageUrls(postContent);
+  const cleanContent = prepareBodyForNewspic(postContent);
+  const cleanPath = join(state.asset_path, "post-clean.md");
+  await writeFile(cleanPath, cleanContent, "utf-8");
+
+  const assets = (state.images.render_assets as RenderAsset[])
+    .filter((asset) => asset.route === "wechat-newspic")
+    .sort((a, b) => {
+      if (a.kind === "cover" && b.kind !== "cover") return -1;
+      if (a.kind !== "cover" && b.kind === "cover") return 1;
+      return (a.index ?? 0) - (b.index ?? 0);
+    });
+
+  const renderPhotos = assets.map((asset) => asset.path);
+  const photos = mergePhotoLists(renderPhotos, bodyImageUrls);
+
+  if (dryRun) {
+    console.error(`[dry-run] Wechat newspic: ${state.metadata.title}`);
+    console.error(`[dry-run] Content file: ${cleanPath}`);
+    return {
+      route: "wechat-newspic",
+      status: "skipped",
+      detail: "dry-run",
+      published_at: null,
+      content_version: state.artifacts.content_version,
+      render_version: state.artifacts.render_version,
+    };
+  }
+
+  try {
+    await createWechatNewspic({
+      account: state.route.account,
+      title: state.metadata.title,
+      content: cleanContent,
+      photos,
+      config,
+    });
+  } catch (error) {
+    return {
+      route: "wechat-newspic",
+      status: "failed",
+      detail: error instanceof Error ? error.message : String(error),
+      published_at: null,
+      content_version: state.artifacts.content_version,
+      render_version: state.artifacts.render_version,
+    };
+  }
+
+  return {
+    route: "wechat-newspic",
+    status: "success",
+    detail: null,
+    published_at: new Date().toISOString(),
+    content_version: state.artifacts.content_version,
+    render_version: state.artifacts.render_version,
+  };
+}
+
+const PUBLISH_PROVIDERS: Partial<Record<RoutePrimary, PublishProvider>> = {
+  "wechat-article": publishWechatArticleRoute,
+  "wechat-newspic": publishWechatNewspicRoute,
+};
+
+export function getPublishProvider(route: RoutePrimary): PublishProvider {
+  const provider = PUBLISH_PROVIDERS[route];
+  if (!provider) {
+    throw new Error(`Unsupported workflow publish route: ${route}`);
+  }
+  return provider;
+}
+
+export function listPublishProviders(): RoutePrimary[] {
+  return Object.keys(PUBLISH_PROVIDERS) as RoutePrimary[];
+}

package/src/providers/wechat.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, test } from "bun:test";
+import {
+  normalizeAccountName,
+  resolveTimeout,
+  parsePhotos,
+  mergePhotoLists,
+  extractImageUrls,
+  replaceImageUrls,
+  isRetryableTokenFetchError,
+  resolveFilenameFromUrl,
+} from "./wechat";
+
+describe("normalizeAccountName", () => {
+  test("accepts valid account names", () => {
+    expect(normalizeAccountName("default")).toBe("default");
+    expect(normalizeAccountName("my-account")).toBe("my-account");
+    expect(normalizeAccountName("account_v2")).toBe("account_v2");
+    expect(normalizeAccountName("test.account")).toBe("test.account");
+  });
+
+  test("trims whitespace", () => {
+    expect(normalizeAccountName("  default  ")).toBe("default");
+  });
+
+  test("throws on empty string", () => {
+    expect(() => normalizeAccountName("")).toThrow("wx account cannot be empty");
+    expect(() => normalizeAccountName("  ")).toThrow("wx account cannot be empty");
+  });
+
+  test("throws on invalid characters", () => {
+    expect(() => normalizeAccountName("my account")).toThrow("invalid wx account");
+    expect(() => normalizeAccountName("account@name")).toThrow("invalid wx account");
+  });
+});
+
+describe("resolveTimeout", () => {
+  test("returns override when valid", () => {
+    expect(resolveTimeout(5000, 10000, 15000)).toBe(15000);
+  });
+
+  test("returns config timeout when override is absent", () => {
+    expect(resolveTimeout(5000, 10000)).toBe(10000);
+  });
+
+  test("returns default when config and override are absent", () => {
+    expect(resolveTimeout(5000, 0)).toBe(5000);
+  });
+
+  test("ignores invalid override (zero, negative, non-finite)", () => {
+    expect(resolveTimeout(5000, 10000, 0)).toBe(10000);
+    expect(resolveTimeout(5000, 10000, -1)).toBe(10000);
+    expect(resolveTimeout(5000, 10000, Infinity)).toBe(10000);
+    expect(resolveTimeout(5000, 10000, NaN)).toBe(10000);
+  });
+
+  test("ignores invalid config timeout", () => {
+    expect(resolveTimeout(5000, -1)).toBe(5000);
+    expect(resolveTimeout(5000, 0)).toBe(5000);
+  });
+});
+
+describe("parsePhotos", () => {
+  test("trims and filters empty entries", () => {
+    expect(parsePhotos(["  img1.png  ", "", "  img2.png  "])).toEqual(["img1.png", "img2.png"]);
+  });
+
+  test("returns empty array for undefined", () => {
+    expect(parsePhotos(undefined)).toEqual([]);
+  });
+
+  test("returns empty array for empty array", () => {
+    expect(parsePhotos([])).toEqual([]);
+  });
+
+  test("filters whitespace-only entries", () => {
+    expect(parsePhotos(["img.png", "  ", "other.png"])).toEqual(["img.png", "other.png"]);
+  });
+});
+
+describe("mergePhotoLists", () => {
+  test("deduplicates across multiple lists", () => {
+    const result = mergePhotoLists(
+      ["a.png", "b.png"],
+      ["b.png", "c.png"],
+      ["c.png", "d.png"],
+    );
+    expect(result).toEqual(["a.png", "b.png", "c.png", "d.png"]);
+  });
+
+  test("handles empty lists", () => {
+    expect(mergePhotoLists([], ["a.png"], [])).toEqual(["a.png"]);
+  });
+
+  test("trims entries before deduplication", () => {
+    expect(mergePhotoLists(["  a.png  "], ["a.png"])).toEqual(["a.png"]);
+  });
+
+  test("filters empty entries", () => {
+    expect(mergePhotoLists(["", "a.png", "  "])).toEqual(["a.png"]);
+  });
+});
+
+describe("extractImageUrls", () => {
+  test("extracts markdown image URLs", () => {
+    const input = "![alt](https://example.com/img.png) and ![other](https://cdn.com/other.jpg)";
+    const urls = extractImageUrls(input);
+    expect(urls).toContain("https://example.com/img.png");
+    expect(urls).toContain("https://cdn.com/other.jpg");
+  });
+
+  test("extracts HTML img src URLs", () => {
+    const input = '<img src="https://example.com/img.png" alt="test">';
+    const urls = extractImageUrls(input);
+    expect(urls).toContain("https://example.com/img.png");
+  });
+
+  test("deduplicates URLs", () => {
+    const input = "![a](https://example.com/img.png) ![b](https://example.com/img.png)";
+    const urls = extractImageUrls(input);
+    expect(urls.filter((u) => u === "https://example.com/img.png")).toHaveLength(1);
+  });
+
+  test("handles mixed markdown and HTML images", () => {
+    const input = '![md](https://a.com/1.png) <img src="https://b.com/2.png">';
+    const urls = extractImageUrls(input);
+    expect(urls).toHaveLength(2);
+  });
+
+  test("returns empty array for no images", () => {
+    expect(extractImageUrls("just text")).toEqual([]);
+  });
+
+  test("handles image with title attribute", () => {
+    const input = '![alt](https://example.com/img.png "title")';
+    const urls = extractImageUrls(input);
+    expect(urls).toContain("https://example.com/img.png");
+  });
+});
+
+describe("replaceImageUrls", () => {
+  test("replaces URLs using the mapping", () => {
+    const html = '<img src="https://old.com/img.png">';
+    const result = replaceImageUrls(html, { "https://old.com/img.png": "https://new.com/img.png" });
+    expect(result).toBe('<img src="https://new.com/img.png">');
+  });
+
+  test("escapes special regex characters in URLs", () => {
+    const html = '<img src="https://old.com/img.png?v=1&size=large">';
+    const result = replaceImageUrls(html, {
+      "https://old.com/img.png?v=1&size=large": "https://new.com/img.png",
+    });
+    expect(result).toBe('<img src="https://new.com/img.png">');
+  });
+
+  test("replaces multiple occurrences", () => {
+    const html = '<img src="https://a.com/1.png"><img src="https://a.com/1.png">';
+    const result = replaceImageUrls(html, { "https://a.com/1.png": "https://b.com/1.png" });
+    expect(result).toBe('<img src="https://b.com/1.png"><img src="https://b.com/1.png">');
+  });
+
+  test("skips empty keys or values", () => {
+    const html = '<img src="https://a.com/1.png">';
+    const result = replaceImageUrls(html, { "": "https://b.com/1.png", "https://a.com/1.png": "" });
+    expect(result).toBe(html);
+  });
+});
+
+describe("isRetryableTokenFetchError", () => {
+  test("returns true for fetch failed errors", () => {
+    expect(isRetryableTokenFetchError(new Error("fetch failed"))).toBe(true);
+    expect(isRetryableTokenFetchError(new Error("Request failed: fetch failed ECONNREFUSED"))).toBe(true);
+  });
+
+  test("returns true case-insensitively", () => {
+    expect(isRetryableTokenFetchError(new Error("Fetch Failed"))).toBe(true);
+    expect(isRetryableTokenFetchError(new Error("FETCH FAILED"))).toBe(true);
+  });
+
+  test("returns false for non-fetch errors", () => {
+    expect(isRetryableTokenFetchError(new Error("timeout"))).toBe(false);
+    expect(isRetryableTokenFetchError(new Error("unauthorized"))).toBe(false);
+  });
+
+  test("returns false for non-Error values", () => {
+    expect(isRetryableTokenFetchError("fetch failed")).toBe(false);
+    expect(isRetryableTokenFetchError(null)).toBe(false);
+    expect(isRetryableTokenFetchError(undefined)).toBe(false);
+  });
+});
+
+describe("resolveFilenameFromUrl", () => {
+  test("uses filename from URL path", () => {
+    expect(resolveFilenameFromUrl("https://cdn.com/photo.png", "image/png", 0)).toBe("photo.png");
+  });
+
+  test("strips query parameters", () => {
+    expect(resolveFilenameFromUrl("https://cdn.com/photo.png?v=1&size=large", "image/png", 0)).toBe("photo.png");
+  });
+
+  test("adds extension when missing", () => {
+    expect(resolveFilenameFromUrl("https://cdn.com/photo", "image/jpeg", 0)).toBe("photo.jpg");
+  });
+
+  test("corrects mismatched extension", () => {
+    expect(resolveFilenameFromUrl("https://cdn.com/photo.gif", "image/png", 0)).toBe("photo.png");
+  });
+
+  test("uses fallback name when URL has no filename", () => {
+    expect(resolveFilenameFromUrl("https://cdn.com/", "image/png", 0)).toBe("image_1.png");
+  });
+
+  test("uses index for fallback naming", () => {
+    expect(resolveFilenameFromUrl("https://cdn.com/", "image/jpeg", 2)).toBe("image_3.jpg");
+  });
+});