esa-pcg-cli 0.1.2 → 0.1.4

package/dist/overrides/tagCache/gateway.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const gateway_auth_1 = require("../../runtime/gateway-auth");
+const cdn_purge_1 = require("../../runtime/cdn-purge");
 const QUERY_TIMEOUT = 3000;
 const WRITE_TIMEOUT = 5000;
 const BATCH_SIZE = 200;
@@ -19,6 +20,8 @@ class GatewayTagCache {
         this.mode = 'nextMode';
         this.config = null;
         this.configLoaded = false;
+        this.purgeClient = null;
+        this.purgeClientLoaded = false;
     }
     getConfig() {
         if (!this.configLoaded) {
@@ -27,6 +30,14 @@ class GatewayTagCache {
         }
         return this.config;
     }
+    getPurgeClient() {
+        if (!this.purgeClientLoaded) {
+            const cfg = (0, cdn_purge_1.loadCdnPurgeConfig)();
+            this.purgeClient = cfg ? (0, cdn_purge_1.createCdnPurgeClient)(cfg) : null;
+            this.purgeClientLoaded = true;
+        }
+        return this.purgeClient;
+    }
     buildTagKey(tag) {
         const config = this.getConfig();
         if (!config)
@@ -134,9 +145,24 @@ class GatewayTagCache {
             };
         });
         await this.batchWrite(config, rows);
+        // 写库成功后,fire-and-forget 触发 ESA 边缘缓存失效。
+        // 任何失败都不应回灌到调用方,所以 catch 直接 warn,不 throw、不 await。
+        const purgeClient = this.getPurgeClient();
+        if (purgeClient) {
+            const tagStrs = tags
+                .map(t => (typeof t === 'string' ? t : t.tag))
+                .filter((s) => typeof s === 'string' && s.length > 0);
+            if (tagStrs.length > 0) {
+                purgeClient.purgeByTags(tagStrs).catch(err => {
+                    var _a;
+                    console.warn(`[tagCache] purge fan-out failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                });
+            }
+        }
     }
     // ---- private methods ----
     async batchGetTags(config, tags) {
+        var _a, _b;
         const primaryKeys = tags.map(tag => [
             { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },
             { name: 'tag', value: this.buildTagKey(tag) },
@@ -157,6 +183,7 @@ class GatewayTagCache {
             return [];
         }
         const data = (await res.json());
+        console.log(`[tagCache] batch-get-row ok: tags=${tags.length} rows=${(_b = (_a = data.rows) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0}`);
         if (!data.rows)
             return [];
         return data.rows.map(row => {
@@ -195,6 +222,9 @@ class GatewayTagCache {
                 if (!res.ok) {
                     console.warn(`[tagCache] batch-write failed: status=${res.status}`);
                 }
+                else {
+                    console.log(`[tagCache] batch-write ok: rows=${batch.length}`);
+                }
             }
             catch (err) {
                 if (err.name === 'AbortError') {
@@ -208,4 +238,4 @@ class GatewayTagCache {
     }
 }
 exports.default = GatewayTagCache;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../../src/overrides/tagCache/gateway.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAEH,6DAIoC;AAEpC,MAAM,aAAa,GAAG,IAAI,CAAC;AAC3B,MAAM,aAAa,GAAG,IAAI,CAAC;AAC3B,MAAM,UAAU,GAAG,GAAG,CAAC;AAEvB,SAAS,iBAAiB,CAAC,CAAS;IAClC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAC/B,CAAC;AAgBD,MAAqB,eAAe;IAApC;QACE,SAAI,GAAG,mBAA4B,CAAC;QACpC,SAAI,GAAG,UAAmB,CAAC;QAEnB,WAAM,GAA6B,IAAI,CAAC;QACxC,iBAAY,GAAG,KAAK,CAAC;IA0N/B,CAAC;IAxNS,SAAS;QACf,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,IAAI,CAAC,MAAM,GAAG,IAAA,oCAAqB,GAAE,CAAC;YACtC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;SAC1B;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAEO,WAAW,CAAC,GAAW;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM;YAAE,OAAO,GAAG,CAAC;QACxB,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC;IACvD,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,IAAc;QACrC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM;YAAE,OAAO,CAAC,CAAC;QAEtB,IAAI;YACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACnD,IAAI,gBAAgB,GAAG,CAAC,CAAC;YACzB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;gBACtB,IAAI,GAAG,CAAC,aAAa,IAAI,GAAG,CAAC,aAAa,GAAG,gBAAgB,EAAE;oBAC7D,gBAAgB,GAAG,GAAG,CAAC,aAAa,CAAC;iBACtC;aACF;YACD,OAAO,gBAAgB,CAAC;SACzB;QAAC,OAAO,GAAQ,EAAE;YACjB,OAAO,CAAC,IAAI,CAAC,wCAAwC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpE,OAAO,CAAC,CAAC;SACV;IACH,CAAC;IAED,KAAK,CAAC,kBAAkB,CACtB,IAAc,EACd,YAAqB;QAErB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAE1B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAEpC,IAAI;YACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACnD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,MAAM,EAAE,GAAG,YAAY,aAAZ,YAAY,cAAZ,YAAY,GAAI,CAAC,CAAC;YAE7B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;gBACtB,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE;oBAC5B,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,EAAE,EAAE;wBACxC,OAAO,IAAI,CAAC;qBACb;iBACF;gBACD,IAAI,GAAG,CAAC,aAAa,KAAK,SAAS,IAAI,GAAG,CAAC,aAAa,GAAG,EAAE,EAAE;oBAC7D,OAAO,IAAI,CAAC;iBACb;aACF;YACD,OAAO,KAAK,CAAC;SACd;QAAC,OAAO,GAAQ,EAAE;YACjB,OAAO,CAAC,IAAI,CAAC,wCAAwC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpE,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,IAAc,EAAE,YAAqB;;QACjD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAE1B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAEpC,IAAI;YACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACnD,MAAM,EAAE,GAAG,YAAY,aAAZ,YAAY,cAAZ,YAAY,GAAI,CAAC,CAAC;YAE7B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;gBACtB,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS;oBAAE,SAAS;gBACtC,MAAM,aAAa,GAAG,MAAA,GAAG,CAAC,aAAa,mCAAI,CAAC,CAAC;gBAC7C,IAAI,aAAa,GAAG,EAAE,IAAI,GAAG,CAAC,KAAK,IAAI,EAAE,EAAE;oBACzC,OAAO,IAAI,CAAC;iBACb;aACF;YACD,OAAO,KAAK,CAAC;SACd;QAAC,OAAO,GAAQ,EAAE;YACjB,OAAO,CAAC,IAAI,CAAC,6BAA6B,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACzD,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,IAAkC;QAChD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAEvC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM;YAAE,OAAO;QAEpB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE3B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YAC5B,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;YAC7D,MAAM,KAAK,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;YAClE,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;YACpE,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YAExC,MAAM,OAAO,GAAsC;gBACjD,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,OAAO,EAAE;aAC1C,CAAC;YACF,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;aAC/C;YACD,IAAI,MAAM,KAAK,SAAS,EAAE;gBACxB,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;aACjD;YAED,OAAO;gBACL,UAAU,EAAE;oBACV,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,WAAW,EAAE,EAAE;oBACnE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE;iBAC/B;gBACD,OAAO;aACR,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;IAED,4BAA4B;IAEpB,KAAK,CAAC,YAAY,CACxB,MAAyB,EACzB,IAAc;QAEd,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,WAAW,EAAE,EAAE;YACnE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE;SAC9C,CAAC,CAAC;QAEH,MAAM,GAAG,GAAG,MAAM,IAAA,2BAAY,EAAC,MAAM,EAAE,sBAAsB,EAAE;YAC7D,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,WAAW,EAAE,CAAC;YACrC,SAAS,EAAE,aAAa;SACzB,CAAC,CAAC;QAEH,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE;YACX,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE;gBAC5C,OAAO,CAAC,KAAK,CACX,sCAAsC,GAAG,CAAC,MAAM,GAAG,CACpD,CAAC;aACH;iBAAM;gBACL,OAAO,CAAC,IAAI,CAAC,2CAA2C,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;aACvE;YACD,OAAO,EAAE,CAAC;SACX;QAED,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAK7B,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO,EAAE,CAAC;QAE1B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;;YACzB,MAAM,MAAM,GAAW,EAAE,CAAC;YAC1B,KAAK,MAAM,GAAG,IAAI,MAAA,GAAG,CAAC,OAAO,mCAAI,EAAE,EAAE;gBACnC,IAAI,GAAG,CAAC,IAAI,KAAK,eAAe,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE;oBACjE,MAAM,CAAC,aAAa,GAAG,GAAG,CAAC,KAAK,CAAC;iBAClC;qBAAM,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE;oBAChE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;iBAC1B;qBAAM,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE;oBACjE,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC;iBAC3B;aACF;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,UAAU,CACtB,MAAyB,EACzB,IAGG;QAEH,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,UAAU,EAAE;YAChD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC;YAE5C,IAAI;gBACF,MAAM,GAAG,GAAG,MAAM,IAAA,2BAAY,EAAC,MAAM,EAAE,oBAAoB,EAAE;oBAC3D,MAAM,EAAE,MAAM;oBACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;oBAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;oBACrC,SAAS,EAAE,aAAa;iBACzB,CAAC,CAAC;gBAEH,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE;oBAC5C,OAAO,CAAC,KAAK,CACX,oCAAoC,GAAG,CAAC,MAAM,GAAG,CAClD,CAAC;oBACF,OAAO;iBACR;gBAED,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE;oBACX,OAAO,CAAC,IAAI,CAAC,yCAAyC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;iBACrE;aACF;YAAC,OAAO,GAAQ,EAAE;gBACjB,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE;oBAC7B,OAAO,CAAC,IAAI,CAAC,mCAAmC,aAAa,KAAK,CAAC,CAAC;iBACrE;qBAAM;oBACL,OAAO,CAAC,IAAI,CAAC,iCAAiC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;iBAC9D;aACF;SACF;IACH,CAAC;CACF;AA/ND,kCA+NC","sourcesContent":["/**\n * Gateway Tag 缓存 Override (nextMode)\n *\n * 使用 OpenNext 的 nextMode 接口，通过 Gateway 代理读写 TableStore。\n * 鉴权统一走 runtime/gateway-auth（HMAC 签名 + 4 header）。\n */\n\nimport {\n  loadGatewayAuthConfig,\n  gatewayFetch,\n  GatewayAuthConfig,\n} from '../../runtime/gateway-auth';\n\nconst QUERY_TIMEOUT = 3000;\nconst WRITE_TIMEOUT = 5000;\nconst BATCH_SIZE = 200;\n\nfunction stripLeadingSlash(s: string): string {\n  return s.replace(/^\\/+/, '');\n}\n\ntype NextModeTagCacheWriteInput =\n  | string\n  | {\n      tag: string;\n      stale?: number;\n      expire?: number;\n    };\n\ninterface TagRow {\n  revalidatedAt?: number;\n  stale?: number;\n  expire?: number;\n}\n\nexport default class GatewayTagCache {\n  name = 'gateway-tag-cache' as const;\n  mode = 'nextMode' as const;\n\n  private config: GatewayAuthConfig | null = null;\n  private configLoaded = false;\n\n  private getConfig(): GatewayAuthConfig | null {\n    if (!this.configLoaded) {\n      this.config = loadGatewayAuthConfig();\n      this.configLoaded = true;\n    }\n    return this.config;\n  }\n\n  private buildTagKey(tag: string): string {\n    const config = this.getConfig();\n    if (!config) return tag;\n    return `${config.version}/${stripLeadingSlash(tag)}`;\n  }\n\n  async getLastRevalidated(tags: string[]): Promise<number> {\n    const config = this.getConfig();\n    if (!config) return 0;\n\n    try {\n      const rows = await this.batchGetTags(config, tags);\n      let maxRevalidatedAt = 0;\n      for (const row of rows) {\n        if (row.revalidatedAt && row.revalidatedAt > maxRevalidatedAt) {\n          maxRevalidatedAt = row.revalidatedAt;\n        }\n      }\n      return maxRevalidatedAt;\n    } catch (err: any) {\n      console.warn(`[tagCache] getLastRevalidated error: ${err.message}`);\n      return 0;\n    }\n  }\n\n  async hasBeenRevalidated(\n    tags: string[],\n    lastModified?: number\n  ): Promise<boolean> {\n    const config = this.getConfig();\n    if (!config) return false;\n\n    if (tags.length === 0) return false;\n\n    try {\n      const rows = await this.batchGetTags(config, tags);\n      const now = Date.now();\n      const lm = lastModified ?? 0;\n\n      for (const row of rows) {\n        if (row.expire !== undefined) {\n          if (row.expire <= now && row.expire > lm) {\n            return true;\n          }\n        }\n        if (row.revalidatedAt !== undefined && row.revalidatedAt > lm) {\n          return true;\n        }\n      }\n      return false;\n    } catch (err: any) {\n      console.warn(`[tagCache] hasBeenRevalidated error: ${err.message}`);\n      return false;\n    }\n  }\n\n  async isStale(tags: string[], lastModified?: number): Promise<boolean> {\n    const config = this.getConfig();\n    if (!config) return false;\n\n    if (tags.length === 0) return false;\n\n    try {\n      const rows = await this.batchGetTags(config, tags);\n      const lm = lastModified ?? 0;\n\n      for (const row of rows) {\n        if (row.stale === undefined) continue;\n        const revalidatedAt = row.revalidatedAt ?? 0;\n        if (revalidatedAt > lm && row.stale >= lm) {\n          return true;\n        }\n      }\n      return false;\n    } catch (err: any) {\n      console.warn(`[tagCache] isStale error: ${err.message}`);\n      return false;\n    }\n  }\n\n  async writeTags(tags: NextModeTagCacheWriteInput[]): Promise<void> {\n    if (!tags || tags.length === 0) return;\n\n    const config = this.getConfig();\n    if (!config) return;\n\n    const writeTs = Date.now();\n\n    const rows = tags.map(input => {\n      const tagStr = typeof input === 'string' ? input : input.tag;\n      const stale = typeof input === 'string' ? undefined : input.stale;\n      const expire = typeof input === 'string' ? undefined : input.expire;\n      const tagKey = this.buildTagKey(tagStr);\n\n      const columns: { name: string; value: number }[] = [\n        { name: 'revalidatedAt', value: writeTs },\n      ];\n      if (stale !== undefined) {\n        columns.push({ name: 'stale', value: stale });\n      }\n      if (expire !== undefined) {\n        columns.push({ name: 'expire', value: expire });\n      }\n\n      return {\n        primaryKey: [\n          { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },\n          { name: 'tag', value: tagKey },\n        ],\n        columns,\n      };\n    });\n\n    await this.batchWrite(config, rows);\n  }\n\n  // ---- private methods ----\n\n  private async batchGetTags(\n    config: GatewayAuthConfig,\n    tags: string[]\n  ): Promise<TagRow[]> {\n    const primaryKeys = tags.map(tag => [\n      { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },\n      { name: 'tag', value: this.buildTagKey(tag) },\n    ]);\n\n    const res = await gatewayFetch(config, '/table/batch-get-row', {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({ primaryKeys }),\n      timeoutMs: QUERY_TIMEOUT,\n    });\n\n    if (!res.ok) {\n      if (res.status === 401 || res.status === 403) {\n        console.error(\n          `[tagCache] batch-get-row rejected (${res.status})`\n        );\n      } else {\n        console.warn(`[tagCache] batch-get-row failed: status=${res.status}`);\n      }\n      return [];\n    }\n\n    const data = (await res.json()) as {\n      rows?: {\n        primaryKey?: any[];\n        columns?: { name: string; value: number }[];\n      }[];\n    };\n\n    if (!data.rows) return [];\n\n    return data.rows.map(row => {\n      const result: TagRow = {};\n      for (const col of row.columns ?? []) {\n        if (col.name === 'revalidatedAt' && typeof col.value === 'number') {\n          result.revalidatedAt = col.value;\n        } else if (col.name === 'stale' && typeof col.value === 'number') {\n          result.stale = col.value;\n        } else if (col.name === 'expire' && typeof col.value === 'number') {\n          result.expire = col.value;\n        }\n      }\n      return result;\n    });\n  }\n\n  private async batchWrite(\n    config: GatewayAuthConfig,\n    rows: {\n      primaryKey: { name: string; value: string | number }[];\n      columns: { name: string; value: string | number }[];\n    }[]\n  ): Promise<void> {\n    if (rows.length === 0) return;\n\n    for (let i = 0; i < rows.length; i += BATCH_SIZE) {\n      const batch = rows.slice(i, i + BATCH_SIZE);\n\n      try {\n        const res = await gatewayFetch(config, '/table/batch-write', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ rows: batch }),\n          timeoutMs: WRITE_TIMEOUT,\n        });\n\n        if (res.status === 401 || res.status === 403) {\n          console.error(\n            `[tagCache] batch-write rejected (${res.status})`\n          );\n          return;\n        }\n\n        if (!res.ok) {\n          console.warn(`[tagCache] batch-write failed: status=${res.status}`);\n        }\n      } catch (err: any) {\n        if (err.name === 'AbortError') {\n          console.warn(`[tagCache] batch-write timeout (${WRITE_TIMEOUT}ms)`);\n        } else {\n          console.warn(`[tagCache] batch-write error: ${err.message}`);\n        }\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../../src/overrides/tagCache/gateway.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Gateway Tag 缓存 Override (nextMode)\n *\n * 使用 OpenNext 的 nextMode 接口，通过 Gateway 代理读写 TableStore。\n * 鉴权统一走 runtime/gateway-auth（HMAC 签名 + 4 header）。\n */\n\nimport {\n  loadGatewayAuthConfig,\n  gatewayFetch,\n  GatewayAuthConfig,\n} from '../../runtime/gateway-auth';\nimport {\n  loadCdnPurgeConfig,\n  createCdnPurgeClient,\n  CdnPurgeClient,\n} from '../../runtime/cdn-purge';\n\nconst QUERY_TIMEOUT = 3000;\nconst WRITE_TIMEOUT = 5000;\nconst BATCH_SIZE = 200;\n\nfunction stripLeadingSlash(s: string): string {\n  return s.replace(/^\\/+/, '');\n}\n\ntype NextModeTagCacheWriteInput =\n  | string\n  | {\n      tag: string;\n      stale?: number;\n      expire?: number;\n    };\n\ninterface TagRow {\n  revalidatedAt?: number;\n  stale?: number;\n  expire?: number;\n}\n\nexport default class GatewayTagCache {\n  name = 'gateway-tag-cache' as const;\n  mode = 'nextMode' as const;\n\n  private config: GatewayAuthConfig | null = null;\n  private configLoaded = false;\n\n  private purgeClient: CdnPurgeClient | null = null;\n  private purgeClientLoaded = false;\n\n  private getConfig(): GatewayAuthConfig | null {\n    if (!this.configLoaded) {\n      this.config = loadGatewayAuthConfig();\n      this.configLoaded = true;\n    }\n    return this.config;\n  }\n\n  private getPurgeClient(): CdnPurgeClient | null {\n    if (!this.purgeClientLoaded) {\n      const cfg = loadCdnPurgeConfig();\n      this.purgeClient = cfg ? createCdnPurgeClient(cfg) : null;\n      this.purgeClientLoaded = true;\n    }\n    return this.purgeClient;\n  }\n\n  private buildTagKey(tag: string): string {\n    const config = this.getConfig();\n    if (!config) return tag;\n    return `${config.version}/${stripLeadingSlash(tag)}`;\n  }\n\n  async getLastRevalidated(tags: string[]): Promise<number> {\n    const config = this.getConfig();\n    if (!config) return 0;\n\n    try {\n      const rows = await this.batchGetTags(config, tags);\n      let maxRevalidatedAt = 0;\n      for (const row of rows) {\n        if (row.revalidatedAt && row.revalidatedAt > maxRevalidatedAt) {\n          maxRevalidatedAt = row.revalidatedAt;\n        }\n      }\n      return maxRevalidatedAt;\n    } catch (err: any) {\n      console.warn(`[tagCache] getLastRevalidated error: ${err.message}`);\n      return 0;\n    }\n  }\n\n  async hasBeenRevalidated(\n    tags: string[],\n    lastModified?: number\n  ): Promise<boolean> {\n    const config = this.getConfig();\n    if (!config) return false;\n\n    if (tags.length === 0) return false;\n\n    try {\n      const rows = await this.batchGetTags(config, tags);\n      const now = Date.now();\n      const lm = lastModified ?? 0;\n\n      for (const row of rows) {\n        if (row.expire !== undefined) {\n          if (row.expire <= now && row.expire > lm) {\n            return true;\n          }\n        }\n        if (row.revalidatedAt !== undefined && row.revalidatedAt > lm) {\n          return true;\n        }\n      }\n      return false;\n    } catch (err: any) {\n      console.warn(`[tagCache] hasBeenRevalidated error: ${err.message}`);\n      return false;\n    }\n  }\n\n  async isStale(tags: string[], lastModified?: number): Promise<boolean> {\n    const config = this.getConfig();\n    if (!config) return false;\n\n    if (tags.length === 0) return false;\n\n    try {\n      const rows = await this.batchGetTags(config, tags);\n      const lm = lastModified ?? 0;\n\n      for (const row of rows) {\n        if (row.stale === undefined) continue;\n        const revalidatedAt = row.revalidatedAt ?? 0;\n        if (revalidatedAt > lm && row.stale >= lm) {\n          return true;\n        }\n      }\n      return false;\n    } catch (err: any) {\n      console.warn(`[tagCache] isStale error: ${err.message}`);\n      return false;\n    }\n  }\n\n  async writeTags(tags: NextModeTagCacheWriteInput[]): Promise<void> {\n    if (!tags || tags.length === 0) return;\n\n    const config = this.getConfig();\n    if (!config) return;\n\n    const writeTs = Date.now();\n\n    const rows = tags.map(input => {\n      const tagStr = typeof input === 'string' ? input : input.tag;\n      const stale = typeof input === 'string' ? undefined : input.stale;\n      const expire = typeof input === 'string' ? undefined : input.expire;\n      const tagKey = this.buildTagKey(tagStr);\n\n      const columns: { name: string; value: number }[] = [\n        { name: 'revalidatedAt', value: writeTs },\n      ];\n      if (stale !== undefined) {\n        columns.push({ name: 'stale', value: stale });\n      }\n      if (expire !== undefined) {\n        columns.push({ name: 'expire', value: expire });\n      }\n\n      return {\n        primaryKey: [\n          { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },\n          { name: 'tag', value: tagKey },\n        ],\n        columns,\n      };\n    });\n\n    await this.batchWrite(config, rows);\n\n    // 写库成功后,fire-and-forget 触发 ESA 边缘缓存失效。\n    // 任何失败都不应回灌到调用方,所以 catch 直接 warn,不 throw、不 await。\n    const purgeClient = this.getPurgeClient();\n    if (purgeClient) {\n      const tagStrs = tags\n        .map(t => (typeof t === 'string' ? t : t.tag))\n        .filter((s): s is string => typeof s === 'string' && s.length > 0);\n      if (tagStrs.length > 0) {\n        purgeClient.purgeByTags(tagStrs).catch(err => {\n          console.warn(`[tagCache] purge fan-out failed: ${err?.message ?? err}`);\n        });\n      }\n    }\n  }\n\n  // ---- private methods ----\n\n  private async batchGetTags(\n    config: GatewayAuthConfig,\n    tags: string[]\n  ): Promise<TagRow[]> {\n    const primaryKeys = tags.map(tag => [\n      { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },\n      { name: 'tag', value: this.buildTagKey(tag) },\n    ]);\n\n    const res = await gatewayFetch(config, '/table/batch-get-row', {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({ primaryKeys }),\n      timeoutMs: QUERY_TIMEOUT,\n    });\n\n    if (!res.ok) {\n      if (res.status === 401 || res.status === 403) {\n        console.error(\n          `[tagCache] batch-get-row rejected (${res.status})`\n        );\n      } else {\n        console.warn(`[tagCache] batch-get-row failed: status=${res.status}`);\n      }\n      return [];\n    }\n\n    const data = (await res.json()) as {\n      rows?: {\n        primaryKey?: any[];\n        columns?: { name: string; value: number }[];\n      }[];\n    };\n\n    console.log(\n      `[tagCache] batch-get-row ok: tags=${tags.length} rows=${data.rows?.length ?? 0}`\n    );\n\n    if (!data.rows) return [];\n\n    return data.rows.map(row => {\n      const result: TagRow = {};\n      for (const col of row.columns ?? []) {\n        if (col.name === 'revalidatedAt' && typeof col.value === 'number') {\n          result.revalidatedAt = col.value;\n        } else if (col.name === 'stale' && typeof col.value === 'number') {\n          result.stale = col.value;\n        } else if (col.name === 'expire' && typeof col.value === 'number') {\n          result.expire = col.value;\n        }\n      }\n      return result;\n    });\n  }\n\n  private async batchWrite(\n    config: GatewayAuthConfig,\n    rows: {\n      primaryKey: { name: string; value: string | number }[];\n      columns: { name: string; value: string | number }[];\n    }[]\n  ): Promise<void> {\n    if (rows.length === 0) return;\n\n    for (let i = 0; i < rows.length; i += BATCH_SIZE) {\n      const batch = rows.slice(i, i + BATCH_SIZE);\n\n      try {\n        const res = await gatewayFetch(config, '/table/batch-write', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ rows: batch }),\n          timeoutMs: WRITE_TIMEOUT,\n        });\n\n        if (res.status === 401 || res.status === 403) {\n          console.error(\n            `[tagCache] batch-write rejected (${res.status})`\n          );\n          return;\n        }\n\n        if (!res.ok) {\n          console.warn(`[tagCache] batch-write failed: status=${res.status}`);\n        } else {\n          console.log(`[tagCache] batch-write ok: rows=${batch.length}`);\n        }\n      } catch (err: any) {\n        if (err.name === 'AbortError') {\n          console.warn(`[tagCache] batch-write timeout (${WRITE_TIMEOUT}ms)`);\n        } else {\n          console.warn(`[tagCache] batch-write error: ${err.message}`);\n        }\n      }\n    }\n  }\n}\n"]}

package/dist/runtime/cdn-purge.d.ts

@@ -0,0 +1,53 @@
+/**
+ * CDN Purge Runtime
+ *
+ * 在 revalidateTag / revalidatePath 后,fire-and-forget 触发 ESA 边缘缓存失效。
+ *
+ * 设计原则:
+ *   - tag → paths 反查走 **本地** manifest(build 时由 pcg build 把
+ *     .open-next/dynamodb-provider/dynamodb-cache.json 嵌入 FC bundle),
+ *     运行时第一次用到时 lazy 加载到内存 Map,后续 O(1) 查询,无网络往返
+ *   - /cache/refresh 走 Gateway,沿用现有 HMAC 鉴权 + ESA 分流
+ *   - 所有失败仅 warn,绝不抛错(purge 是优化,不是正确性)
+ *   - hostname / siteId 走 per-request edge-context(AsyncLocalStorage),
+ *     由 node-server wrapper 从入站请求 header 注入;ctx 缺这两项时 skip + warn,
+ *     不再静默生效。鉴权(5 env)缺失则 loadCdnPurgeConfig 返回 null,
+ *     上游降级 no-op,连 client 都不构造。
+ *   - 跨 tag 反查结果去重,每 path 追加 /_next/data/{buildId}/{path}.json
+ *   - 调 /cache/refresh 时按 100 URL/批、batch 内并发上限 4
+ */
+import { GatewayAuthConfig } from './gateway-auth';
+export interface CdnPurgeConfig extends GatewayAuthConfig {
+    /**
+     * 覆盖默认 manifest 路径,主要给测试用。
+     * 默认 = path.join(__dirname, '__pcg_tag_manifest.json'),
+     * 即 FC bundle 内与 cache.cjs 同级。
+     */
+    manifestPath?: string;
+}
+export interface CdnPurgeClient {
+    /**
+     * 异步触发 ESA 缓存失效。不阻塞调用方,失败仅 warn。
+     * 内部完成 path 去重 + ISR 数据路径补全 + 限流。
+     */
+    purgeByPaths(paths: string[]): Promise<void>;
+    /**
+     * tag → paths 反查 + purge。
+     * 反查走本地嵌入的 manifest 文件,无网络 IO。
+     */
+    purgeByTags(tags: string[]): Promise<void>;
+}
+/**
+ * 加载 purge 配置。
+ *
+ * hostname / siteId 不再从 env 取,改由 node-server wrapper 在入口
+ * runWithEdgeContext(headers, …) 把请求头里的 host 与 x-alicdn-site-id 注入
+ * AsyncLocalStorage,refreshBatch 时即时读取。原因:
+ *   - 一个 routine 可能服务多 site / 多 hostname,启动期 env 无法表达
+ *   - 本地 dev 若没带头,这次 purge 直接 skip + warn,不再静默生效
+ *
+ * 复用 loadGatewayAuthConfig 的 5 个 env 做 HMAC 鉴权 / endpoint 选取。
+ * 缺这五个 env 返回 null,调用方应跳过 purge(不影响 tag 写库)。
+ */
+export declare function loadCdnPurgeConfig(): CdnPurgeConfig | null;
+export declare function createCdnPurgeClient(cfg: CdnPurgeConfig): CdnPurgeClient;

package/dist/runtime/cdn-purge.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * CDN Purge Runtime
+ *
+ * 在 revalidateTag / revalidatePath 后,fire-and-forget 触发 ESA 边缘缓存失效。
+ *
+ * 设计原则:
+ *   - tag → paths 反查走 **本地** manifest(build 时由 pcg build 把
+ *     .open-next/dynamodb-provider/dynamodb-cache.json 嵌入 FC bundle),
+ *     运行时第一次用到时 lazy 加载到内存 Map,后续 O(1) 查询,无网络往返
+ *   - /cache/refresh 走 Gateway,沿用现有 HMAC 鉴权 + ESA 分流
+ *   - 所有失败仅 warn,绝不抛错(purge 是优化,不是正确性)
+ *   - hostname / siteId 走 per-request edge-context(AsyncLocalStorage),
+ *     由 node-server wrapper 从入站请求 header 注入;ctx 缺这两项时 skip + warn,
+ *     不再静默生效。鉴权(5 env)缺失则 loadCdnPurgeConfig 返回 null,
+ *     上游降级 no-op,连 client 都不构造。
+ *   - 跨 tag 反查结果去重,每 path 追加 /_next/data/{buildId}/{path}.json
+ *   - 调 /cache/refresh 时按 100 URL/批、batch 内并发上限 4
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCdnPurgeClient = exports.loadCdnPurgeConfig = void 0;
+const fs = require("fs");
+const path = require("path");
+const gateway_auth_1 = require("./gateway-auth");
+const edge_context_1 = require("./edge-context");
+const REFRESH_TIMEOUT_MS = 15000;
+const URL_BATCH_SIZE = 100;
+const REFRESH_CONCURRENCY = 4;
+// 与 build.ts 中 TAG_MANIFEST_FILENAME 保持一致(对侧是写入,这侧是读取)
+const TAG_MANIFEST_FILENAME = '__pcg_tag_manifest.json';
+function stripLeadingSlash(s) {
+    return s.replace(/^\/+/, '');
+}
+function ensureLeadingSlash(s) {
+    return s.startsWith('/') ? s : `/${s}`;
+}
+/**
+ * 加载 purge 配置。
+ *
+ * hostname / siteId 不再从 env 取,改由 node-server wrapper 在入口
+ * runWithEdgeContext(headers, …) 把请求头里的 host 与 x-alicdn-site-id 注入
+ * AsyncLocalStorage,refreshBatch 时即时读取。原因:
+ *   - 一个 routine 可能服务多 site / 多 hostname,启动期 env 无法表达
+ *   - 本地 dev 若没带头,这次 purge 直接 skip + warn,不再静默生效
+ *
+ * 复用 loadGatewayAuthConfig 的 5 个 env 做 HMAC 鉴权 / endpoint 选取。
+ * 缺这五个 env 返回 null,调用方应跳过 purge(不影响 tag 写库)。
+ */
+function loadCdnPurgeConfig() {
+    const base = (0, gateway_auth_1.loadGatewayAuthConfig)();
+    if (!base)
+        return null;
+    return { ...base };
+}
+exports.loadCdnPurgeConfig = loadCdnPurgeConfig;
+function createCdnPurgeClient(cfg) {
+    var _a;
+    const buildId = cfg.version;
+    const pathPrefix = `${buildId}/`;
+    const manifestPath = (_a = cfg.manifestPath) !== null && _a !== void 0 ? _a : path.join(__dirname, TAG_MANIFEST_FILENAME);
+    // lazy 加载;Promise 用于并发首次调用的合流
+    let manifestPromise = null;
+    async function loadManifest() {
+        if (manifestPromise)
+            return manifestPromise;
+        manifestPromise = (async () => {
+            var _a, _b, _c, _d;
+            const map = new Map();
+            let raw;
+            try {
+                raw = await fs.promises.readFile(manifestPath, 'utf-8');
+            }
+            catch (err) {
+                // ENOENT 是常见情况(纯静态项目无 tag,或老版 CLI 未嵌入),静默降级
+                if ((err === null || err === void 0 ? void 0 : err.code) !== 'ENOENT') {
+                    console.warn(`[cdn-purge] manifest read error ${manifestPath}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                }
+                return new Map();
+            }
+            let rows;
+            try {
+                const parsed = JSON.parse(raw);
+                rows = Array.isArray(parsed) ? parsed : [];
+            }
+            catch (err) {
+                console.warn(`[cdn-purge] manifest parse error ${manifestPath}: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+                return new Map();
+            }
+            for (const row of rows) {
+                const tagPk = (_c = row === null || row === void 0 ? void 0 : row.tag) === null || _c === void 0 ? void 0 : _c.S;
+                const pathPk = (_d = row === null || row === void 0 ? void 0 : row.path) === null || _d === void 0 ? void 0 : _d.S;
+                if (typeof tagPk !== 'string' || typeof pathPk !== 'string')
+                    continue;
+                // 只接受当前 buildId 的行;OpenNext 已保证 prefix,但万一混入旧行就跳过
+                if (!tagPk.startsWith(pathPrefix))
+                    continue;
+                if (!pathPk.startsWith(pathPrefix))
+                    continue;
+                const tag = tagPk.slice(pathPrefix.length);
+                const p = pathPk.slice(pathPrefix.length);
+                if (!tag || !p)
+                    continue;
+                let bucket = map.get(tag);
+                if (!bucket) {
+                    bucket = new Set();
+                    map.set(tag, bucket);
+                }
+                bucket.add(p);
+            }
+            const result = new Map();
+            let totalEntries = 0;
+            for (const [tag, set] of map) {
+                result.set(tag, Array.from(set));
+                totalEntries += set.size;
+            }
+            console.log(`[cdn-purge] manifest loaded: tags=${result.size} entries=${totalEntries} (${manifestPath})`);
+            return result;
+        })();
+        return manifestPromise;
+    }
+    /**
+     * 把若干 Next 路由 path 展开成需 purge 的 URL 列表:
+     *   - 跳过空串、去重(基于规范化后的 leading "/")
+     *   - 对每个 path 追加 /_next/data/{buildId}/{path}.json
+     *   - 拼上 https://{hostname}
+     */
+    function expandPathsToUrls(paths, hostname) {
+        const normalized = new Set();
+        for (const p of paths) {
+            if (!p)
+                continue;
+            normalized.add(ensureLeadingSlash(p));
+        }
+        if (normalized.size === 0)
+            return [];
+        const urls = new Set();
+        for (const p of normalized) {
+            urls.add(`https://${hostname}${p}`);
+            const rel = stripLeadingSlash(p);
+            // pages router ISR 必需;app router 多打一条无副作用
+            urls.add(`https://${hostname}/_next/data/${buildId}/${rel || 'index'}.json`);
+        }
+        return Array.from(urls);
+    }
+    async function refreshBatch(urls, hostname, siteId) {
+        var _a;
+        const body = {
+            hostname,
+            siteId,
+            urls,
+        };
+        let res;
+        try {
+            res = await (0, gateway_auth_1.gatewayFetch)(cfg, '/cache/refresh', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                timeoutMs: REFRESH_TIMEOUT_MS,
+            });
+        }
+        catch (err) {
+            console.warn(`[cdn-purge] cache/refresh error (${urls.length} urls): ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            return;
+        }
+        if (!res.ok) {
+            let detail = '';
+            try {
+                detail = (await res.text()).slice(0, 200);
+            }
+            catch (_b) {
+                /* ignore */
+            }
+            console.warn(`[cdn-purge] cache/refresh failed status=${res.status} urls=${urls.length} ${detail}`);
+            return;
+        }
+        console.log(`[cdn-purge] cache/refresh ok: urls=${urls.length}`);
+    }
+    async function refreshUrls(allUrls, hostname, siteId) {
+        if (allUrls.length === 0)
+            return;
+        const batches = [];
+        for (let i = 0; i < allUrls.length; i += URL_BATCH_SIZE) {
+            batches.push(allUrls.slice(i, i + URL_BATCH_SIZE));
+        }
+        // 并发上限 REFRESH_CONCURRENCY 的滑动窗口
+        let cursor = 0;
+        async function worker() {
+            while (cursor < batches.length) {
+                const idx = cursor++;
+                await refreshBatch(batches[idx], hostname, siteId);
+            }
+        }
+        const workers = Array.from({ length: Math.min(REFRESH_CONCURRENCY, batches.length) }, () => worker());
+        await Promise.all(workers);
+    }
+    /**
+     * 从当前请求的 AsyncLocalStorage 拿 hostname/siteId。
+     * 缺任一即返回 null,调用方 warn 后 skip — 本地无 header 路径就是这条降级。
+     */
+    function resolveTarget(action) {
+        const { hostname, siteId } = (0, edge_context_1.getEdgeContext)();
+        if (!hostname || siteId === undefined || siteId === '') {
+            console.warn(`[cdn-purge] ${action} skip: edge context missing (hostname=${hostname !== null && hostname !== void 0 ? hostname : '∅'} siteId=${siteId !== null && siteId !== void 0 ? siteId : '∅'}); ` +
+                `要求入站请求带 host 与 x-alicdn-site-id`);
+            return null;
+        }
+        return { hostname, siteId };
+    }
+    async function purgeByPaths(paths) {
+        var _a;
+        try {
+            const target = resolveTarget('purgeByPaths');
+            if (!target)
+                return;
+            const urls = expandPathsToUrls(paths, target.hostname);
+            console.log(`[cdn-purge] purgeByPaths: input=${paths.length} urls=${urls.length}`);
+            await refreshUrls(urls, target.hostname, target.siteId);
+        }
+        catch (err) {
+            console.warn(`[cdn-purge] purgeByPaths error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
+    async function purgeByTags(tags) {
+        var _a;
+        try {
+            const uniqueTags = Array.from(new Set(tags
+                .map(t => (typeof t === 'string' ? t : ''))
+                .map(t => t.trim())
+                .filter(Boolean)));
+            if (uniqueTags.length === 0)
+                return;
+            const target = resolveTarget('purgeByTags');
+            if (!target)
+                return;
+            const map = await loadManifest();
+            const merged = new Set();
+            for (const t of uniqueTags) {
+                const paths = map.get(t);
+                if (!paths)
+                    continue;
+                for (const p of paths)
+                    merged.add(p);
+            }
+            if (merged.size === 0) {
+                console.log(`[cdn-purge] purgeByTags: input=${uniqueTags.length} matched=0 (manifest miss, skip)`);
+                return;
+            }
+            const urls = expandPathsToUrls(Array.from(merged), target.hostname);
+            console.log(`[cdn-purge] purgeByTags: input=${uniqueTags.length} matched=${merged.size} urls=${urls.length}`);
+            await refreshUrls(urls, target.hostname, target.siteId);
+        }
+        catch (err) {
+            console.warn(`[cdn-purge] purgeByTags error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
+    return { purgeByPaths, purgeByTags };
+}
+exports.createCdnPurgeClient = createCdnPurgeClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdn-purge.js","sourceRoot":"","sources":["../../src/runtime/cdn-purge.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CDN Purge Runtime\n *\n * 在 revalidateTag / revalidatePath 后,fire-and-forget 触发 ESA 边缘缓存失效。\n *\n * 设计原则:\n *   - tag → paths 反查走 **本地** manifest(build 时由 pcg build 把\n *     .open-next/dynamodb-provider/dynamodb-cache.json 嵌入 FC bundle),\n *     运行时第一次用到时 lazy 加载到内存 Map,后续 O(1) 查询,无网络往返\n *   - /cache/refresh 走 Gateway,沿用现有 HMAC 鉴权 + ESA 分流\n *   - 所有失败仅 warn,绝不抛错(purge 是优化,不是正确性)\n *   - hostname / siteId 走 per-request edge-context(AsyncLocalStorage),\n *     由 node-server wrapper 从入站请求 header 注入;ctx 缺这两项时 skip + warn,\n *     不再静默生效。鉴权(5 env)缺失则 loadCdnPurgeConfig 返回 null,\n *     上游降级 no-op,连 client 都不构造。\n *   - 跨 tag 反查结果去重,每 path 追加 /_next/data/{buildId}/{path}.json\n *   - 调 /cache/refresh 时按 100 URL/批、batch 内并发上限 4\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { CacheRefreshRequest } from '@pcg/protocol';\nimport {\n  loadGatewayAuthConfig,\n  gatewayFetch,\n  GatewayAuthConfig,\n} from './gateway-auth';\nimport { getEdgeContext } from './edge-context';\n\nconst REFRESH_TIMEOUT_MS = 15_000;\n\nconst URL_BATCH_SIZE = 100;\nconst REFRESH_CONCURRENCY = 4;\n\n// 与 build.ts 中 TAG_MANIFEST_FILENAME 保持一致(对侧是写入,这侧是读取)\nconst TAG_MANIFEST_FILENAME = '__pcg_tag_manifest.json';\n\nexport interface CdnPurgeConfig extends GatewayAuthConfig {\n  /**\n   * 覆盖默认 manifest 路径,主要给测试用。\n   * 默认 = path.join(__dirname, '__pcg_tag_manifest.json'),\n   * 即 FC bundle 内与 cache.cjs 同级。\n   */\n  manifestPath?: string;\n}\n\nexport interface CdnPurgeClient {\n  /**\n   * 异步触发 ESA 缓存失效。不阻塞调用方,失败仅 warn。\n   * 内部完成 path 去重 + ISR 数据路径补全 + 限流。\n   */\n  purgeByPaths(paths: string[]): Promise<void>;\n\n  /**\n   * tag → paths 反查 + purge。\n   * 反查走本地嵌入的 manifest 文件,无网络 IO。\n   */\n  purgeByTags(tags: string[]): Promise<void>;\n}\n\nfunction stripLeadingSlash(s: string): string {\n  return s.replace(/^\\/+/, '');\n}\n\nfunction ensureLeadingSlash(s: string): string {\n  return s.startsWith('/') ? s : `/${s}`;\n}\n\n/**\n * 加载 purge 配置。\n *\n * hostname / siteId 不再从 env 取,改由 node-server wrapper 在入口\n * runWithEdgeContext(headers, …) 把请求头里的 host 与 x-alicdn-site-id 注入\n * AsyncLocalStorage,refreshBatch 时即时读取。原因:\n *   - 一个 routine 可能服务多 site / 多 hostname,启动期 env 无法表达\n *   - 本地 dev 若没带头,这次 purge 直接 skip + warn,不再静默生效\n *\n * 复用 loadGatewayAuthConfig 的 5 个 env 做 HMAC 鉴权 / endpoint 选取。\n * 缺这五个 env 返回 null,调用方应跳过 purge(不影响 tag 写库)。\n */\nexport function loadCdnPurgeConfig(): CdnPurgeConfig | null {\n  const base = loadGatewayAuthConfig();\n  if (!base) return null;\n  return { ...base };\n}\n\n/**\n * dynamodb-provider/dynamodb-cache.json 的行格式 ——\n * 由 OpenNext build 直接产出,字段名固定为 DynamoDB 属性映射格式。\n */\ninterface DynamoTagRow {\n  tag: { S: string };\n  path: { S: string };\n  revalidatedAt?: { N: string };\n}\n\nexport function createCdnPurgeClient(cfg: CdnPurgeConfig): CdnPurgeClient {\n  const buildId = cfg.version;\n  const pathPrefix = `${buildId}/`;\n  const manifestPath =\n    cfg.manifestPath ?? path.join(__dirname, TAG_MANIFEST_FILENAME);\n\n  // lazy 加载;Promise 用于并发首次调用的合流\n  let manifestPromise: Promise<Map<string, string[]>> | null = null;\n\n  async function loadManifest(): Promise<Map<string, string[]>> {\n    if (manifestPromise) return manifestPromise;\n    manifestPromise = (async () => {\n      const map = new Map<string, Set<string>>();\n      let raw: string;\n      try {\n        raw = await fs.promises.readFile(manifestPath, 'utf-8');\n      } catch (err: any) {\n        // ENOENT 是常见情况(纯静态项目无 tag,或老版 CLI 未嵌入),静默降级\n        if (err?.code !== 'ENOENT') {\n          console.warn(\n            `[cdn-purge] manifest read error ${manifestPath}: ${err?.message ?? err}`\n          );\n        }\n        return new Map<string, string[]>();\n      }\n      let rows: DynamoTagRow[];\n      try {\n        const parsed = JSON.parse(raw);\n        rows = Array.isArray(parsed) ? parsed : [];\n      } catch (err: any) {\n        console.warn(\n          `[cdn-purge] manifest parse error ${manifestPath}: ${err?.message ?? err}`\n        );\n        return new Map<string, string[]>();\n      }\n\n      for (const row of rows) {\n        const tagPk = row?.tag?.S;\n        const pathPk = row?.path?.S;\n        if (typeof tagPk !== 'string' || typeof pathPk !== 'string') continue;\n        // 只接受当前 buildId 的行;OpenNext 已保证 prefix,但万一混入旧行就跳过\n        if (!tagPk.startsWith(pathPrefix)) continue;\n        if (!pathPk.startsWith(pathPrefix)) continue;\n        const tag = tagPk.slice(pathPrefix.length);\n        const p = pathPk.slice(pathPrefix.length);\n        if (!tag || !p) continue;\n        let bucket = map.get(tag);\n        if (!bucket) {\n          bucket = new Set<string>();\n          map.set(tag, bucket);\n        }\n        bucket.add(p);\n      }\n\n      const result = new Map<string, string[]>();\n      let totalEntries = 0;\n      for (const [tag, set] of map) {\n        result.set(tag, Array.from(set));\n        totalEntries += set.size;\n      }\n      console.log(\n        `[cdn-purge] manifest loaded: tags=${result.size} entries=${totalEntries} (${manifestPath})`\n      );\n      return result;\n    })();\n    return manifestPromise;\n  }\n\n  /**\n   * 把若干 Next 路由 path 展开成需 purge 的 URL 列表:\n   *   - 跳过空串、去重(基于规范化后的 leading \"/\")\n   *   - 对每个 path 追加 /_next/data/{buildId}/{path}.json\n   *   - 拼上 https://{hostname}\n   */\n  function expandPathsToUrls(paths: string[], hostname: string): string[] {\n    const normalized = new Set<string>();\n    for (const p of paths) {\n      if (!p) continue;\n      normalized.add(ensureLeadingSlash(p));\n    }\n    if (normalized.size === 0) return [];\n\n    const urls = new Set<string>();\n    for (const p of normalized) {\n      urls.add(`https://${hostname}${p}`);\n      const rel = stripLeadingSlash(p);\n      // pages router ISR 必需;app router 多打一条无副作用\n      urls.add(\n        `https://${hostname}/_next/data/${buildId}/${rel || 'index'}.json`\n      );\n    }\n    return Array.from(urls);\n  }\n\n  async function refreshBatch(\n    urls: string[],\n    hostname: string,\n    siteId: string | number\n  ): Promise<void> {\n    const body: CacheRefreshRequest = {\n      hostname,\n      siteId,\n      urls,\n    };\n\n    let res: Response;\n    try {\n      res = await gatewayFetch(cfg, '/cache/refresh', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(body),\n        timeoutMs: REFRESH_TIMEOUT_MS,\n      });\n    } catch (err: any) {\n      console.warn(\n        `[cdn-purge] cache/refresh error (${urls.length} urls): ${err?.message ?? err}`\n      );\n      return;\n    }\n\n    if (!res.ok) {\n      let detail = '';\n      try {\n        detail = (await res.text()).slice(0, 200);\n      } catch {\n        /* ignore */\n      }\n      console.warn(\n        `[cdn-purge] cache/refresh failed status=${res.status} urls=${urls.length} ${detail}`\n      );\n      return;\n    }\n    console.log(`[cdn-purge] cache/refresh ok: urls=${urls.length}`);\n  }\n\n  async function refreshUrls(\n    allUrls: string[],\n    hostname: string,\n    siteId: string | number\n  ): Promise<void> {\n    if (allUrls.length === 0) return;\n\n    const batches: string[][] = [];\n    for (let i = 0; i < allUrls.length; i += URL_BATCH_SIZE) {\n      batches.push(allUrls.slice(i, i + URL_BATCH_SIZE));\n    }\n\n    // 并发上限 REFRESH_CONCURRENCY 的滑动窗口\n    let cursor = 0;\n    async function worker(): Promise<void> {\n      while (cursor < batches.length) {\n        const idx = cursor++;\n        await refreshBatch(batches[idx], hostname, siteId);\n      }\n    }\n\n    const workers = Array.from(\n      { length: Math.min(REFRESH_CONCURRENCY, batches.length) },\n      () => worker()\n    );\n    await Promise.all(workers);\n  }\n\n  /**\n   * 从当前请求的 AsyncLocalStorage 拿 hostname/siteId。\n   * 缺任一即返回 null,调用方 warn 后 skip — 本地无 header 路径就是这条降级。\n   */\n  function resolveTarget(\n    action: string\n  ): { hostname: string; siteId: string | number } | null {\n    const { hostname, siteId } = getEdgeContext();\n    if (!hostname || siteId === undefined || siteId === '') {\n      console.warn(\n        `[cdn-purge] ${action} skip: edge context missing (hostname=${hostname ?? '∅'} siteId=${siteId ?? '∅'}); ` +\n          `要求入站请求带 host 与 x-alicdn-site-id`\n      );\n      return null;\n    }\n    return { hostname, siteId };\n  }\n\n  async function purgeByPaths(paths: string[]): Promise<void> {\n    try {\n      const target = resolveTarget('purgeByPaths');\n      if (!target) return;\n      const urls = expandPathsToUrls(paths, target.hostname);\n      console.log(\n        `[cdn-purge] purgeByPaths: input=${paths.length} urls=${urls.length}`\n      );\n      await refreshUrls(urls, target.hostname, target.siteId);\n    } catch (err: any) {\n      console.warn(`[cdn-purge] purgeByPaths error: ${err?.message ?? err}`);\n    }\n  }\n\n  async function purgeByTags(tags: string[]): Promise<void> {\n    try {\n      const uniqueTags = Array.from(\n        new Set(\n          tags\n            .map(t => (typeof t === 'string' ? t : ''))\n            .map(t => t.trim())\n            .filter(Boolean)\n        )\n      );\n      if (uniqueTags.length === 0) return;\n\n      const target = resolveTarget('purgeByTags');\n      if (!target) return;\n\n      const map = await loadManifest();\n\n      const merged = new Set<string>();\n      for (const t of uniqueTags) {\n        const paths = map.get(t);\n        if (!paths) continue;\n        for (const p of paths) merged.add(p);\n      }\n      if (merged.size === 0) {\n        console.log(\n          `[cdn-purge] purgeByTags: input=${uniqueTags.length} matched=0 (manifest miss, skip)`\n        );\n        return;\n      }\n\n      const urls = expandPathsToUrls(Array.from(merged), target.hostname);\n      console.log(\n        `[cdn-purge] purgeByTags: input=${uniqueTags.length} matched=${merged.size} urls=${urls.length}`\n      );\n      await refreshUrls(urls, target.hostname, target.siteId);\n    } catch (err: any) {\n      console.warn(`[cdn-purge] purgeByTags error: ${err?.message ?? err}`);\n    }\n  }\n\n  return { purgeByPaths, purgeByTags };\n}\n"]}

package/dist/runtime/edge-context.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Edge Request Context
+ *
+ * 在 ESA / 边缘环境,siteId 和 hostname 从入站请求 header 取,不再依赖
+ * 启动时 env 注入。原因:
+ *   - 一个 routine 实例可能服务多个 site / hostname(灰度、多版本、聚合域),
+ *     启动时 env 无法表达 per-request 变化
+ *   - 让 ops 不必再为每个部署额外配两个 env
+ *
+ * 实现用 AsyncLocalStorage:
+ *   - node-server wrapper 在 handler 入口处 runWithEdgeContext(headers, fn)
+ *   - 下游 cdn-purge / 其他模块用 getEdgeContext() 同步读取
+ *   - 即使 purge 是 fire-and-forget,promise 链也会继承当前 ALS,
+ *     refreshBatch 内仍能拿到当时请求的 ctx
+ *
+ * 关键 header:
+ *   - x-alicdn-site-id  → siteId
+ *   - host / x-forwarded-host → hostname(首选 host,缺失才退 x-forwarded-host)
+ */
+export interface EdgeContext {
+    siteId?: string | number;
+    hostname?: string;
+}
+export declare function buildEdgeContextFromHeaders(headers: Record<string, string | undefined>): EdgeContext;
+export declare function runWithEdgeContext<T>(headers: Record<string, string | undefined>, fn: () => T): T;
+export declare function getEdgeContext(): EdgeContext;

package/dist/runtime/edge-context.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Edge Request Context
+ *
+ * 在 ESA / 边缘环境,siteId 和 hostname 从入站请求 header 取,不再依赖
+ * 启动时 env 注入。原因:
+ *   - 一个 routine 实例可能服务多个 site / hostname(灰度、多版本、聚合域),
+ *     启动时 env 无法表达 per-request 变化
+ *   - 让 ops 不必再为每个部署额外配两个 env
+ *
+ * 实现用 AsyncLocalStorage:
+ *   - node-server wrapper 在 handler 入口处 runWithEdgeContext(headers, fn)
+ *   - 下游 cdn-purge / 其他模块用 getEdgeContext() 同步读取
+ *   - 即使 purge 是 fire-and-forget,promise 链也会继承当前 ALS,
+ *     refreshBatch 内仍能拿到当时请求的 ctx
+ *
+ * 关键 header:
+ *   - x-alicdn-site-id  → siteId
+ *   - host / x-forwarded-host → hostname(首选 host,缺失才退 x-forwarded-host)
+ */
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEdgeContext = exports.runWithEdgeContext = exports.buildEdgeContextFromHeaders = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+// OpenNext build 把 wrapper / tagCache 等分别作为 esbuild 入口打包,即便同一 routine
+// 里 edge-context.ts 也会被复制成多份 —— 每份各自 `new AsyncLocalStorage()`,
+// store 互不可见,wrapper 注入的 ctx 在 cdn-purge 一侧读到永远是 undefined。
+// 用 Symbol.for 把单例挂到 globalThis,所有副本拿到同一个 ALS。
+const ALS_KEY = Symbol.for('pcg.edgeContext.als');
+const globalRef = globalThis;
+const storage = (_a = globalRef[ALS_KEY]) !== null && _a !== void 0 ? _a : (globalRef[ALS_KEY] = new node_async_hooks_1.AsyncLocalStorage());
+const SITE_ID_HEADER = 'x-alicdn-site-id';
+const HOSTNAME_HEADER = 'host';
+const FORWARDED_HOSTNAME_HEADER = 'x-forwarded-host';
+function pickHeader(headers, name) {
+    var _a;
+    return (_a = headers[name]) !== null && _a !== void 0 ? _a : headers[name.toLowerCase()];
+}
+function parseHostname(raw) {
+    var _a;
+    if (!raw)
+        return undefined;
+    const first = (_a = raw.split(',')[0]) === null || _a === void 0 ? void 0 : _a.trim();
+    return first || undefined;
+}
+function parseSiteId(raw) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    const n = Number(trimmed);
+    return Number.isFinite(n) && trimmed === String(n) ? n : trimmed;
+}
+function buildEdgeContextFromHeaders(headers) {
+    var _a;
+    const ctx = {};
+    const siteId = parseSiteId(pickHeader(headers, SITE_ID_HEADER));
+    if (siteId !== undefined)
+        ctx.siteId = siteId;
+    const hostname = (_a = parseHostname(pickHeader(headers, HOSTNAME_HEADER))) !== null && _a !== void 0 ? _a : parseHostname(pickHeader(headers, FORWARDED_HOSTNAME_HEADER));
+    if (hostname)
+        ctx.hostname = hostname;
+    return ctx;
+}
+exports.buildEdgeContextFromHeaders = buildEdgeContextFromHeaders;
+function runWithEdgeContext(headers, fn) {
+    const ctx = buildEdgeContextFromHeaders(headers);
+    return storage.run(ctx, fn);
+}
+exports.runWithEdgeContext = runWithEdgeContext;
+function getEdgeContext() {
+    var _a;
+    return (_a = storage.getStore()) !== null && _a !== void 0 ? _a : {};
+}
+exports.getEdgeContext = getEdgeContext;
+//# sourceMappingURL=data:application/json;base64,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