@zhin.js/adapter-weixin-ilink 0.1.0

package/src/upload.test.ts

@@ -0,0 +1,305 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+vi.mock("./ilink-logger.js", () => ({
+  logger: {
+    info: vi.fn(),
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+const { mockGetUploadUrl } = vi.hoisted(() => ({
+  mockGetUploadUrl: vi.fn(),
+}));
+
+vi.mock("./ilink-api.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./ilink-api.js")>();
+  return {
+    ...actual,
+    getUploadUrl: mockGetUploadUrl,
+  };
+});
+
+const { mockFetch } = vi.hoisted(() => ({
+  mockFetch: vi.fn(),
+}));
+vi.stubGlobal("fetch", mockFetch);
+
+function mockCdnResponse(params: {
+  ok?: boolean;
+  status?: number;
+  headers?: Record<string, string>;
+  body?: string;
+}) {
+  const headers = new Headers(params.headers ?? {});
+  return {
+    ok: params.ok ?? true,
+    status: params.status ?? 200,
+    headers,
+    text: () => Promise.resolve(params.body ?? ""),
+  };
+}
+
+import { downloadRemoteImageToTemp, uploadFileToWeixin, uploadVideoToWeixin, uploadFileAttachmentToWeixin } from "./upload.js";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("downloadRemoteImageToTemp", () => {
+  it("downloads and saves file to temp dir", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-test-"));
+    try {
+      const imageBytes = Buffer.from("fake-image-data");
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        arrayBuffer: () => Promise.resolve(imageBytes.buffer.slice(imageBytes.byteOffset, imageBytes.byteOffset + imageBytes.byteLength)),
+        headers: new Headers({ "content-type": "image/png" }),
+      });
+      const filePath = await downloadRemoteImageToTemp("https://example.com/photo.png", tmpDir);
+      expect(filePath).toContain(tmpDir);
+      expect(filePath).toMatch(/\.png$/);
+      const content = await fs.readFile(filePath);
+      expect(content.toString()).toBe("fake-image-data");
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("throws on non-ok response", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+    });
+    await expect(
+      downloadRemoteImageToTemp("https://example.com/missing.png", "/tmp/test"),
+    ).rejects.toThrow("remote media download failed");
+  });
+});
+
+describe("uploadFileToWeixin", () => {
+  it("uploads image file and returns info", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-img-test-"));
+    try {
+      const filePath = path.join(tmpDir, "test.png");
+      await fs.writeFile(filePath, "fake-image-data");
+
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up-param" });
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({ headers: { "x-encrypted-param": "dl-param" } }),
+      );
+
+      const result = await uploadFileToWeixin({
+        filePath,
+        toUserId: "user1",
+        opts: { baseUrl: "https://api.com", token: "tok" },
+        cdnBaseUrl: "https://cdn.com",
+      });
+
+      expect(result.filekey).toBeDefined();
+      expect(result.downloadEncryptedQueryParam).toBe("dl-param");
+      expect(result.fileSize).toBe(15);
+      expect(result.fileSizeCiphertext).toBe(16);
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("uploads via upload_full_url when upload_param is absent", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-fullurl-test-"));
+    try {
+      const filePath = path.join(tmpDir, "test.png");
+      await fs.writeFile(filePath, "fake-image-data");
+
+      const fullUrl = "http://cdn.example/c2c/upload?encrypted_query_param=x&filekey=y";
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_full_url: fullUrl });
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({ headers: { "x-encrypted-param": "dl-full" } }),
+      );
+
+      const result = await uploadFileToWeixin({
+        filePath,
+        toUserId: "user1",
+        opts: { baseUrl: "https://api.com", token: "tok" },
+        cdnBaseUrl: "https://ignored-cdn.com",
+      });
+
+      expect(result.downloadEncryptedQueryParam).toBe("dl-full");
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [calledUrl] = mockFetch.mock.calls[0] as [string, RequestInit];
+      expect(calledUrl).toBe(fullUrl);
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("throws when getUploadUrl returns neither upload_full_url nor upload_param", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-fail-test-"));
+    try {
+      const filePath = path.join(tmpDir, "test.txt");
+      await fs.writeFile(filePath, "data");
+
+      mockGetUploadUrl.mockResolvedValueOnce({});
+
+      await expect(
+        uploadFileToWeixin({
+          filePath,
+          toUserId: "user1",
+          opts: { baseUrl: "https://api.com" },
+          cdnBaseUrl: "https://cdn.com",
+        }),
+      ).rejects.toThrow("no upload URL");
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("retries CDN upload on server error then succeeds", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-retry-test-"));
+    try {
+      const filePath = path.join(tmpDir, "data.bin");
+      await fs.writeFile(filePath, "some data for upload");
+
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
+
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({
+          ok: false,
+          status: 500,
+          headers: { "x-error-message": "server busy" },
+          body: "server busy",
+        }),
+      );
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({ headers: { "x-encrypted-param": "dl-retry" } }),
+      );
+
+      const result = await uploadFileToWeixin({
+        filePath,
+        toUserId: "user1",
+        opts: { baseUrl: "https://api.com" },
+        cdnBaseUrl: "https://cdn.com",
+      });
+      expect(result.downloadEncryptedQueryParam).toBe("dl-retry");
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("throws immediately on CDN client error (4xx)", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-4xx-test-"));
+    try {
+      const filePath = path.join(tmpDir, "data.bin");
+      await fs.writeFile(filePath, "data");
+
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({
+          ok: false,
+          status: 403,
+          headers: { "x-error-message": "forbidden" },
+          body: "forbidden",
+        }),
+      );
+
+      await expect(
+        uploadFileToWeixin({
+          filePath,
+          toUserId: "user1",
+          opts: { baseUrl: "https://api.com" },
+          cdnBaseUrl: "https://cdn.com",
+        }),
+      ).rejects.toThrow("client error");
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("throws when CDN returns no x-encrypted-param after all retries", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-no-param-test-"));
+    try {
+      const filePath = path.join(tmpDir, "data.bin");
+      await fs.writeFile(filePath, "data");
+
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
+
+      for (let i = 0; i < 3; i++) {
+        mockFetch.mockResolvedValueOnce(mockCdnResponse({ headers: {} }));
+      }
+
+      await expect(
+        uploadFileToWeixin({
+          filePath,
+          toUserId: "user1",
+          opts: { baseUrl: "https://api.com" },
+          cdnBaseUrl: "https://cdn.com",
+        }),
+      ).rejects.toThrow("x-encrypted-param");
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("uploadVideoToWeixin", () => {
+  it("uploads video file", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-vid-test-"));
+    try {
+      const filePath = path.join(tmpDir, "clip.mp4");
+      await fs.writeFile(filePath, "fake-video-content");
+
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up-vid" });
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({ headers: { "x-encrypted-param": "dl-vid" } }),
+      );
+
+      const result = await uploadVideoToWeixin({
+        filePath,
+        toUserId: "user1",
+        opts: { baseUrl: "https://api.com" },
+        cdnBaseUrl: "https://cdn.com",
+      });
+
+      expect(result.filekey).toBeDefined();
+      expect(result.downloadEncryptedQueryParam).toBe("dl-vid");
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("uploadFileAttachmentToWeixin", () => {
+  it("uploads file attachment", async () => {
+    const tmpDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "upload-att-test-"));
+    try {
+      const filePath = path.join(tmpDir, "doc.pdf");
+      await fs.writeFile(filePath, "pdf-content");
+
+      mockGetUploadUrl.mockResolvedValueOnce({ upload_param: "up" });
+      mockFetch.mockResolvedValueOnce(
+        mockCdnResponse({ headers: { "x-encrypted-param": "dl" } }),
+      );
+
+      const result = await uploadFileAttachmentToWeixin({
+        filePath,
+        fileName: "doc.pdf",
+        toUserId: "user1",
+        opts: { baseUrl: "https://api.com" },
+        cdnBaseUrl: "https://cdn.com",
+      });
+      expect(result.filekey).toBeDefined();
+      expect(result.downloadEncryptedQueryParam).toBe("dl");
+    } finally {
+      fsSync.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/upload.ts

@@ -0,0 +1,157 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { getUploadUrl } from "./ilink-api.js";
+import type { WeixinApiOptions } from "./ilink-api.js";
+import { aesEcbPaddedSize } from "./aes-ecb.js";
+import { uploadBufferToCdn } from "./cdn-upload.js";
+import { logger } from "./ilink-logger.js";
+import { getExtensionFromContentTypeOrUrl } from "./mime.js";
+import { tempFileName } from "./ilink-random.js";
+import { UploadMediaType } from "./ilink-types.js";
+
+export type UploadedFileInfo = {
+  filekey: string;
+  /** 由 upload_param 上传后 CDN 返回的下载加密参数; fill into ImageItem.media.encrypt_query_param */
+  downloadEncryptedQueryParam: string;
+  /** AES-128-ECB key, hex-encoded; convert to base64 for CDNMedia.aes_key */
+  aeskey: string;
+  /** Plaintext file size in bytes */
+  fileSize: number;
+  /** Ciphertext file size in bytes (AES-128-ECB with PKCS7 padding); use for ImageItem.hd_size / mid_size */
+  fileSizeCiphertext: number;
+};
+
+/**
+ * Download a remote media URL (image, video, file) to a local temp file in destDir.
+ * Returns the local file path; extension is inferred from Content-Type / URL.
+ */
+export async function downloadRemoteImageToTemp(url: string, destDir: string): Promise<string> {
+  logger.debug(`downloadRemoteImageToTemp: fetching url=${url}`);
+  const res = await fetch(url);
+  if (!res.ok) {
+    const msg = `remote media download failed: ${res.status} ${res.statusText} url=${url}`;
+    logger.error(`downloadRemoteImageToTemp: ${msg}`);
+    throw new Error(msg);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  logger.debug(`downloadRemoteImageToTemp: downloaded ${buf.length} bytes`);
+  await fs.mkdir(destDir, { recursive: true });
+  const ext = getExtensionFromContentTypeOrUrl(res.headers.get("content-type"), url);
+  const name = tempFileName("weixin-remote", ext);
+  const filePath = path.join(destDir, name);
+  await fs.writeFile(filePath, buf);
+  logger.debug(`downloadRemoteImageToTemp: saved to ${filePath} ext=${ext}`);
+  return filePath;
+}
+
+/**
+ * Common upload pipeline: read file → hash → gen aeskey → getUploadUrl → uploadBufferToCdn → return info.
+ */
+async function uploadMediaToCdn(params: {
+  filePath: string;
+  toUserId: string;
+  opts: WeixinApiOptions;
+  cdnBaseUrl: string;
+  mediaType: (typeof UploadMediaType)[keyof typeof UploadMediaType];
+  label: string;
+}): Promise<UploadedFileInfo> {
+  const { filePath, toUserId, opts, cdnBaseUrl, mediaType, label } = params;
+
+  const plaintext = await fs.readFile(filePath);
+  const rawsize = plaintext.length;
+  const rawfilemd5 = crypto.createHash("md5").update(plaintext).digest("hex");
+  const filesize = aesEcbPaddedSize(rawsize);
+  const filekey = crypto.randomBytes(16).toString("hex");
+  const aeskey = crypto.randomBytes(16);
+
+  logger.debug(
+    `${label}: file=${filePath} rawsize=${rawsize} filesize=${filesize} md5=${rawfilemd5} filekey=${filekey}`,
+  );
+
+  const uploadUrlResp = await getUploadUrl({
+    ...opts,
+    filekey,
+    media_type: mediaType,
+    to_user_id: toUserId,
+    rawsize,
+    rawfilemd5,
+    filesize,
+    no_need_thumb: true,
+    aeskey: aeskey.toString("hex"),
+  });
+
+  const uploadFullUrl = uploadUrlResp.upload_full_url?.trim();
+  const uploadParam = uploadUrlResp.upload_param;
+  if (!uploadFullUrl && !uploadParam) {
+    logger.error(
+      `${label}: getUploadUrl returned no upload URL (need upload_full_url or upload_param), resp=${JSON.stringify(uploadUrlResp)}`,
+    );
+    throw new Error(`${label}: getUploadUrl returned no upload URL`);
+  }
+
+  const { downloadParam: downloadEncryptedQueryParam } = await uploadBufferToCdn({
+    buf: plaintext,
+    uploadFullUrl: uploadFullUrl || undefined,
+    uploadParam: uploadParam ?? undefined,
+    filekey,
+    cdnBaseUrl,
+    aeskey,
+    label: `${label}[orig filekey=${filekey}]`,
+  });
+
+  return {
+    filekey,
+    downloadEncryptedQueryParam,
+    aeskey: aeskey.toString("hex"),
+    fileSize: rawsize,
+    fileSizeCiphertext: filesize,
+  };
+}
+
+/** Upload a local image file to the Weixin CDN with AES-128-ECB encryption. */
+export async function uploadFileToWeixin(params: {
+  filePath: string;
+  toUserId: string;
+  opts: WeixinApiOptions;
+  cdnBaseUrl: string;
+}): Promise<UploadedFileInfo> {
+  return uploadMediaToCdn({
+    ...params,
+    mediaType: UploadMediaType.IMAGE,
+    label: "uploadFileToWeixin",
+  });
+}
+
+/** Upload a local video file to the Weixin CDN. */
+export async function uploadVideoToWeixin(params: {
+  filePath: string;
+  toUserId: string;
+  opts: WeixinApiOptions;
+  cdnBaseUrl: string;
+}): Promise<UploadedFileInfo> {
+  return uploadMediaToCdn({
+    ...params,
+    mediaType: UploadMediaType.VIDEO,
+    label: "uploadVideoToWeixin",
+  });
+}
+
+/**
+ * Upload a local file attachment (non-image, non-video) to the Weixin CDN.
+ * Uses media_type=FILE; no thumbnail required.
+ */
+export async function uploadFileAttachmentToWeixin(params: {
+  filePath: string;
+  fileName: string;
+  toUserId: string;
+  opts: WeixinApiOptions;
+  cdnBaseUrl: string;
+}): Promise<UploadedFileInfo> {
+  return uploadMediaToCdn({
+    ...params,
+    mediaType: UploadMediaType.FILE,
+    label: "uploadFileAttachmentToWeixin",
+  });
+}