[v1.4] 脚本资源更新逻辑重构 ( updateResource 相关代码 ) 与 并发控制优化 (资源更新同步机制) 重构

e2e/gm-api.spec.ts

@@ -177,7 +177,7 @@ function patchTargetMatchCode(code: string, targetUrl: string): string {
   const url = new URL(targetUrl);
   const targetPattern = `${url.protocol}//${url.hostname}/*${url.search}`;
   return code.replace(
-    /^\/\/\s*@match\s+.*\?(gm_api_sync|gm_api_async|inject_content|WINDOW_MESSAGE_TEST_SC|SANDBOX_TEST_SC)$/gm,
+    /^\/\/\s*@match\s+.*\?(gm_api_sync|gm_api_async|inject_content|WINDOW_MESSAGE_TEST_SC|SANDBOX_TEST_SC|unwrap_e2e_test)$/gm,
     `// @match        ${targetPattern}`
   );
 }
@@ -366,7 +366,7 @@ test.describe("GM API", () => {
       context,
       extensionId,
       "unwrap_e2e_test.js",
-      TARGET_URL,
+      `${gmApiMockServer.cspOrigin}/?unwrap_e2e_test`,
       60_000
     );
 

example/tests/unwrap_e2e_test.js

@@ -4,7 +4,7 @@
 // @version      1.0.0
 // @description  E2E 测试 @unwrap 功能
 // @author       ScriptCat
-// @match        https://content-security-policy.com/*
+// @match        https://content-security-policy.com/?unwrap_e2e_test
 // @grant        GM_setValue
 // @unwrap
 // ==/UserScript==

src/app/repo/resource.ts

@@ -11,7 +11,7 @@ export interface Resource {
   hash: ResourceHash;
   type: ResourceType;
   link: { [key: string]: boolean }; // 关联的脚本
-  contentType: string;
+  contentType: string; // 下载成功的话必定有 contentType. 下载失败的话则没有 （空Resource）
   createtime: number;
   updatetime?: number;
 }

src/app/service/service_worker/resource.test.ts

@@ -3,6 +3,10 @@ import { ResourceService } from "./resource";
 import { vi, describe, it, expect, beforeEach } from "vitest";
 import type { Group } from "@Packages/message/server";
 import type { IMessageQueue } from "@Packages/message/message_queue";
+import { parseUrlSRI } from "./utils";
+import type { Script } from "@App/app/repo/scripts";
+import { SCRIPT_RUN_STATUS_COMPLETE, SCRIPT_STATUS_ENABLE, SCRIPT_TYPE_NORMAL } from "@App/app/repo/scripts";
+import type { Resource } from "@App/app/repo/resource";
 
 initTestEnv();
 
@@ -27,7 +31,42 @@ function mockResponse(blob: Blob, status = 200, contentType?: string) {
   } as unknown as Response;
 }
 
-describe("ResourceService - loadByUrl", () => {
+function normalScript(uuid: string, metadata: Script["metadata"]): Script {
+  return {
+    uuid,
+    name: uuid,
+    namespace: "test",
+    metadata,
+    type: SCRIPT_TYPE_NORMAL,
+    status: SCRIPT_STATUS_ENABLE,
+    sort: 0,
+    runStatus: SCRIPT_RUN_STATUS_COMPLETE,
+    createtime: Date.now(),
+    checktime: 0,
+  } as Script;
+}
+
+function resourceModel(url: string, content: string, updatetime = Date.now()): Resource {
+  return {
+    url,
+    content,
+    contentType: "text/plain",
+    hash: {
+      md5: "mock-md5",
+      sha1: "",
+      sha256: "",
+      sha384: "",
+      sha512: "",
+    },
+    base64: btoa(content),
+    link: { "old-script": true },
+    type: "resource",
+    createtime: updatetime,
+    updatetime,
+  };
+}
+
+describe("ResourceService - createResourceByUrlFetch", () => {
   let service: ResourceService;
 
   beforeEach(() => {
@@ -49,20 +88,21 @@ describe("ResourceService - loadByUrl", () => {
     const jsCode = "console.log('hello');";
     mockFetch.mockResolvedValue(mockResponse(textBlob(jsCode), 200, "application/javascript; charset=utf-8"));
 
-    const res = await service.loadByUrl("https://example.com/lib.js", "require");
+    const res = await service.createResourceByUrlFetch(parseUrlSRI("https://example.com/lib.js"), "require");
 
     expect(res.url).toBe("https://example.com/lib.js");
     expect(res.content).toBeTruthy();
     expect(res.contentType).toBe("application/javascript");
     expect(res.base64).toBeTruthy();
     expect(res.type).toBe("require");
+    expect(res.updatetime).toEqual(expect.any(Number));
   });
 
   it("加载文本资源(resource)时应通过 blob.text() 设置 content", async () => {
     const text = "plain text content";
     mockFetch.mockResolvedValue(mockResponse(textBlob(text), 200, "text/plain"));
 
-    const res = await service.loadByUrl("https://example.com/data.txt", "resource");
+    const res = await service.createResourceByUrlFetch(parseUrlSRI("https://example.com/data.txt"), "resource");
 
     expect(res.content).toBe(text);
     expect(res.type).toBe("resource");
@@ -73,7 +113,7 @@ describe("ResourceService - loadByUrl", () => {
     const bytes = [0x89, 0x50, 0x4e, 0x47, 0x00, 0x00, 0x00, 0x00];
     mockFetch.mockResolvedValue(mockResponse(binaryBlob(bytes), 200, "image/png"));
 
-    const res = await service.loadByUrl("https://example.com/img.png", "resource");
+    const res = await service.createResourceByUrlFetch(parseUrlSRI("https://example.com/img.png"), "resource");
 
     expect(res.content).toBe("");
     expect(res.base64).toBeTruthy();
@@ -83,16 +123,104 @@ describe("ResourceService - loadByUrl", () => {
   it("响应非200时应抛出异常", async () => {
     mockFetch.mockResolvedValue(mockResponse(textBlob(""), 404));
 
-    await expect(service.loadByUrl("https://example.com/404", "require")).rejects.toThrow(
+    await expect(service.createResourceByUrlFetch(parseUrlSRI("https://example.com/404"), "require")).rejects.toThrow(
       "resource response status not 200: 404"
     );
   });
 
   it("没有 content-type 时应默认为 application/octet-stream", async () => {
     mockFetch.mockResolvedValue(mockResponse(textBlob("data"), 200));
 
-    const res = await service.loadByUrl("https://example.com/noct", "resource");
+    const res = await service.createResourceByUrlFetch(parseUrlSRI("https://example.com/noct"), "resource");
 
     expect(res.contentType).toBe("application/octet-stream");
   });
+
+  it("已下载成功的远程资源在24小时内不应重复 fetch", async () => {
+    const url = "https://example.com/cache-ttl.js";
+    const script = normalScript("resource-cache-ttl-test", { require: [url] });
+
+    mockFetch.mockResolvedValue(mockResponse(textBlob("console.log('cache');"), 200, "application/javascript"));
+
+    await service.updateResourceByTypes(script, ["require"]);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    mockFetch.mockClear();
+    await service.updateResourceByTypes(script, ["require"]);
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("多个脚本复用同一 URL 时, TTL 命中也应登记当前脚本的 link", async () => {
+    const url = "https://example.com/shared-lib.js";
+    const scriptA = normalScript("shared-script-a", { require: [url] });
+    const scriptB = normalScript("shared-script-b", { require: [url] });
+
+    mockFetch.mockResolvedValue(mockResponse(textBlob("console.log('shared');"), 200, "application/javascript"));
+
+    // A 安装：实际下载并登记 link
+    await service.updateResourceByTypes(scriptA, ["require"]);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+
+    // B 安装：24 小时内 TTL 命中，不应重新 fetch
+    mockFetch.mockClear();
+    await service.updateResourceByTypes(scriptB, ["require"]);
+    expect(mockFetch).not.toHaveBeenCalled();
+
+    // 但 B 仍应被登记到该资源的 link，否则删除 A 时会误删仍被 B 使用的资源
+    const stored = await service.resourceDAO.get(url);
+    expect(stored?.link).toMatchObject({
+      "shared-script-a": true,
+      "shared-script-b": true,
+    });
+  });
+
+  it("已过期的远程资源应重新 fetch 并更新内容", async () => {
+    const url = "https://example.com/expired.css";
+    const script = normalScript("resource-expired-test", { resource: [`expired ${url}`] });
+    const oldResource = resourceModel(url, "old", Date.now() - 86_400_000 - 1000);
+    vi.spyOn(service, "getResourceModel").mockResolvedValue(oldResource);
+    const updateResource = vi.spyOn(service, "updateResource").mockResolvedValue({
+      ...oldResource,
+      content: "new",
+      updatetime: Date.now(),
+    });
+
+    await service.updateResourceByTypes(script, ["resource"]);
+
+    expect(updateResource).toHaveBeenCalledWith(script.uuid, expect.objectContaining({ url }), "resource", oldResource);
+  });
+
+  it("file 协议资源即使未过期也应尝试更新", async () => {
+    const url = "file:///tmp/scriptcat-resource.txt";
+    const script = normalScript("resource-file-test", { resource: [`localFile ${url}`] });
+    const oldResource = resourceModel(url, "old");
+    vi.spyOn(service, "getResourceModel").mockResolvedValue(oldResource);
+    const updateResource = vi.spyOn(service, "updateResource").mockResolvedValue({
+      ...oldResource,
+      content: "new",
+      updatetime: Date.now(),
+    });
+
+    await service.updateResourceByTypes(script, ["resource"]);
+
+    expect(updateResource).toHaveBeenCalledWith(script.uuid, expect.objectContaining({ url }), "resource", oldResource);
+  });
+
+  it("已有旧资源时下载失败应返回旧资源", async () => {
+    const url = "https://example.com/fallback.css";
+    const oldResource = resourceModel(url, "old-content");
+    vi.spyOn(service, "createResourceByUrlFetch").mockRejectedValue(new Error("network failed"));
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+    const loggerError = vi.spyOn(service.logger, "error").mockImplementation(() => {});
+
+    try {
+      const res = await service.updateResource("resource-fallback-test", parseUrlSRI(url), "resource", oldResource);
+
+      expect(res).toBe(oldResource);
+    } finally {
+      loggerError.mockRestore();
+      consoleError.mockRestore();
+    }
+  });
 });