esa-pcg-cli 0.1.0

package/dist/overrides/incrementalCache/gateway.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Gateway 增量缓存 Override
+ *
+ * Next.js Function 运行时的增量缓存实现，通过 Gateway 代理读写 OSS。
+ * 鉴权统一走 runtime/gateway-auth（HMAC 签名 + 4 header）。
+ *
+ * @see specs/runtime/incremental-cache-override.spec.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const protocol_1 = require("../../_protocol");
+const gateway_auth_1 = require("../../runtime/gateway-auth");
+const GET_TIMEOUT = 5000;
+const SET_TIMEOUT = 10000;
+const DELETE_TIMEOUT = 5000;
+function buildKey(config, key, isFetch) {
+    return (0, protocol_1.buildOssKey)({
+        appId: `${config.aliuid}/${config.routinename}`,
+        buildId: config.version,
+        key,
+        cacheType: isFetch ? 'fetch' : 'cache',
+    });
+}
+class GatewayIncrementalCache {
+    constructor() {
+        this.name = 'gateway-incremental-cache';
+        this.config = null;
+        this.configLoaded = false;
+    }
+    /**
+     * 延迟加载配置，避免在构造函数中因环境变量缺失而阻塞 Function 启动。
+     */
+    getConfig() {
+        if (!this.configLoaded) {
+            this.config = (0, gateway_auth_1.loadGatewayAuthConfig)();
+            this.configLoaded = true;
+        }
+        return this.config;
+    }
+    /**
+     * 从 Gateway 读取缓存。
+     */
+    async get(key, isFetch) {
+        const config = this.getConfig();
+        if (!config)
+            return null;
+        const ossKey = buildKey(config, key, isFetch);
+        try {
+            const res = await (0, gateway_auth_1.gatewayFetch)(config, `/storage/${ossKey}`, {
+                method: 'GET',
+                timeoutMs: GET_TIMEOUT,
+            });
+            if (res.status === 404)
+                return null;
+            if (!res.ok) {
+                if (res.status === 401 || res.status === 403) {
+                    console.error(`[incrementalCache] GET 被拒绝: key="${ossKey}" (${res.status})，请检查签名 secret 或 key 前缀`);
+                }
+                else {
+                    console.warn(`[incrementalCache] GET 失败: key="${ossKey}", 状态码=${res.status}`);
+                }
+                return null;
+            }
+            const body = await res.text();
+            let envelope;
+            try {
+                envelope = JSON.parse(body);
+            }
+            catch (_a) {
+                console.warn(`[incrementalCache] JSON 解析失败: key="${ossKey}"`);
+                return null;
+            }
+            if (!envelope ||
+                typeof envelope !== 'object' ||
+                typeof envelope.lastModified !== 'number') {
+                console.warn(`[incrementalCache] envelope 格式异常或缺 lastModified: key="${ossKey}"`);
+                return null;
+            }
+            return { value: envelope.value, lastModified: envelope.lastModified };
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                console.warn(`[incrementalCache] GET 超时: key="${ossKey}" (${GET_TIMEOUT}ms)`);
+            }
+            else {
+                console.warn(`[incrementalCache] GET 异常: key="${ossKey}", ${err.message}`);
+            }
+            return null;
+        }
+    }
+    /**
+     * 向 Gateway 写入缓存。
+     */
+    async set(key, value, isFetch) {
+        const config = this.getConfig();
+        if (!config)
+            return;
+        const ossKey = buildKey(config, key, isFetch);
+        const body = JSON.stringify({ lastModified: Date.now(), value });
+        try {
+            const res = await (0, gateway_auth_1.gatewayFetch)(config, `/storage/${ossKey}`, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body,
+                timeoutMs: SET_TIMEOUT,
+            });
+            if (!res.ok) {
+                if (res.status === 401 || res.status === 403) {
+                    console.error(`[incrementalCache] PUT 被拒绝: key="${ossKey}" (${res.status})，请检查签名 secret 或 key 前缀`);
+                }
+                else {
+                    console.warn(`[incrementalCache] PUT 失败: key="${ossKey}", 状态码=${res.status}`);
+                }
+            }
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                console.warn(`[incrementalCache] PUT 超时: key="${ossKey}" (${SET_TIMEOUT}ms)`);
+            }
+            else {
+                console.warn(`[incrementalCache] PUT 异常: key="${ossKey}", ${err.message}`);
+            }
+        }
+    }
+    /**
+     * 通过 Gateway 删除缓存。
+     */
+    async delete(key, isFetch) {
+        const config = this.getConfig();
+        if (!config)
+            return;
+        const ossKey = buildKey(config, key, isFetch);
+        try {
+            const res = await (0, gateway_auth_1.gatewayFetch)(config, `/storage/${ossKey}`, {
+                method: 'DELETE',
+                timeoutMs: DELETE_TIMEOUT,
+            });
+            if (res.status === 404)
+                return;
+            if (!res.ok) {
+                if (res.status === 401 || res.status === 403) {
+                    console.error(`[incrementalCache] DELETE 被拒绝: key="${ossKey}" (${res.status})，请检查签名 secret 或 key 前缀`);
+                }
+                else {
+                    console.warn(`[incrementalCache] DELETE 失败: key="${ossKey}", 状态码=${res.status}`);
+                }
+            }
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                console.warn(`[incrementalCache] DELETE 超时: key="${ossKey}" (${DELETE_TIMEOUT}ms)`);
+            }
+            else {
+                console.warn(`[incrementalCache] DELETE 异常: key="${ossKey}", ${err.message}`);
+            }
+        }
+    }
+}
+exports.default = GatewayIncrementalCache;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway.js","sourceRoot":"","sources":["../../../src/overrides/incrementalCache/gateway.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Gateway 增量缓存 Override\n *\n * Next.js Function 运行时的增量缓存实现，通过 Gateway 代理读写 OSS。\n * 鉴权统一走 runtime/gateway-auth（HMAC 签名 + 4 header）。\n *\n * @see specs/runtime/incremental-cache-override.spec.md\n */\n\nimport { buildOssKey } from '@pcg/protocol';\nimport {\n  loadGatewayAuthConfig,\n  gatewayFetch,\n  GatewayAuthConfig,\n} from '../../runtime/gateway-auth';\n\nconst GET_TIMEOUT = 5000;\nconst SET_TIMEOUT = 10000;\nconst DELETE_TIMEOUT = 5000;\n\nfunction buildKey(\n  config: GatewayAuthConfig,\n  key: string,\n  isFetch?: boolean\n): string {\n  return buildOssKey({\n    appId: `${config.aliuid}/${config.routinename}`,\n    buildId: config.version,\n    key,\n    cacheType: isFetch ? 'fetch' : 'cache',\n  });\n}\n\nexport default class GatewayIncrementalCache {\n  name = 'gateway-incremental-cache' as const;\n\n  private config: GatewayAuthConfig | null = null;\n  private configLoaded = false;\n\n  /**\n   * 延迟加载配置，避免在构造函数中因环境变量缺失而阻塞 Function 启动。\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  /**\n   * 从 Gateway 读取缓存。\n   */\n  async get(\n    key: string,\n    isFetch?: boolean\n  ): Promise<{ value: any; lastModified: number } | null> {\n    const config = this.getConfig();\n    if (!config) return null;\n\n    const ossKey = buildKey(config, key, isFetch);\n\n    try {\n      const res = await gatewayFetch(config, `/storage/${ossKey}`, {\n        method: 'GET',\n        timeoutMs: GET_TIMEOUT,\n      });\n\n      if (res.status === 404) return null;\n\n      if (!res.ok) {\n        if (res.status === 401 || res.status === 403) {\n          console.error(\n            `[incrementalCache] GET 被拒绝: key=\"${ossKey}\" (${res.status})，请检查签名 secret 或 key 前缀`\n          );\n        } else {\n          console.warn(\n            `[incrementalCache] GET 失败: key=\"${ossKey}\", 状态码=${res.status}`\n          );\n        }\n        return null;\n      }\n\n      const body = await res.text();\n      let envelope: { lastModified?: unknown; value?: unknown };\n      try {\n        envelope = JSON.parse(body);\n      } catch {\n        console.warn(`[incrementalCache] JSON 解析失败: key=\"${ossKey}\"`);\n        return null;\n      }\n      if (\n        !envelope ||\n        typeof envelope !== 'object' ||\n        typeof envelope.lastModified !== 'number'\n      ) {\n        console.warn(\n          `[incrementalCache] envelope 格式异常或缺 lastModified: key=\"${ossKey}\"`\n        );\n        return null;\n      }\n      return { value: envelope.value, lastModified: envelope.lastModified };\n    } catch (err: any) {\n      if (err.name === 'AbortError') {\n        console.warn(\n          `[incrementalCache] GET 超时: key=\"${ossKey}\" (${GET_TIMEOUT}ms)`\n        );\n      } else {\n        console.warn(\n          `[incrementalCache] GET 异常: key=\"${ossKey}\", ${err.message}`\n        );\n      }\n      return null;\n    }\n  }\n\n  /**\n   * 向 Gateway 写入缓存。\n   */\n  async set(\n    key: string,\n    value: any,\n    isFetch?: boolean\n  ): Promise<void> {\n    const config = this.getConfig();\n    if (!config) return;\n\n    const ossKey = buildKey(config, key, isFetch);\n    const body = JSON.stringify({ lastModified: Date.now(), value });\n\n    try {\n      const res = await gatewayFetch(config, `/storage/${ossKey}`, {\n        method: 'PUT',\n        headers: { 'Content-Type': 'application/json' },\n        body,\n        timeoutMs: SET_TIMEOUT,\n      });\n\n      if (!res.ok) {\n        if (res.status === 401 || res.status === 403) {\n          console.error(\n            `[incrementalCache] PUT 被拒绝: key=\"${ossKey}\" (${res.status})，请检查签名 secret 或 key 前缀`\n          );\n        } else {\n          console.warn(\n            `[incrementalCache] PUT 失败: key=\"${ossKey}\", 状态码=${res.status}`\n          );\n        }\n      }\n    } catch (err: any) {\n      if (err.name === 'AbortError') {\n        console.warn(\n          `[incrementalCache] PUT 超时: key=\"${ossKey}\" (${SET_TIMEOUT}ms)`\n        );\n      } else {\n        console.warn(\n          `[incrementalCache] PUT 异常: key=\"${ossKey}\", ${err.message}`\n        );\n      }\n    }\n  }\n\n  /**\n   * 通过 Gateway 删除缓存。\n   */\n  async delete(key: string, isFetch?: boolean): Promise<void> {\n    const config = this.getConfig();\n    if (!config) return;\n\n    const ossKey = buildKey(config, key, isFetch);\n\n    try {\n      const res = await gatewayFetch(config, `/storage/${ossKey}`, {\n        method: 'DELETE',\n        timeoutMs: DELETE_TIMEOUT,\n      });\n\n      if (res.status === 404) return;\n\n      if (!res.ok) {\n        if (res.status === 401 || res.status === 403) {\n          console.error(\n            `[incrementalCache] DELETE 被拒绝: key=\"${ossKey}\" (${res.status})，请检查签名 secret 或 key 前缀`\n          );\n        } else {\n          console.warn(\n            `[incrementalCache] DELETE 失败: key=\"${ossKey}\", 状态码=${res.status}`\n          );\n        }\n      }\n    } catch (err: any) {\n      if (err.name === 'AbortError') {\n        console.warn(\n          `[incrementalCache] DELETE 超时: key=\"${ossKey}\" (${DELETE_TIMEOUT}ms)`\n        );\n      } else {\n        console.warn(\n          `[incrementalCache] DELETE 异常: key=\"${ossKey}\", ${err.message}`\n        );\n      }\n    }\n  }\n}\n"]}

package/dist/overrides/tagCache/gateway.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gateway Tag 缓存 Override (nextMode)
+ *
+ * 使用 OpenNext 的 nextMode 接口，通过 Gateway 代理读写 TableStore。
+ * 鉴权统一走 runtime/gateway-auth（HMAC 签名 + 4 header）。
+ */
+declare type NextModeTagCacheWriteInput = string | {
+    tag: string;
+    stale?: number;
+    expire?: number;
+};
+export default class GatewayTagCache {
+    name: "gateway-tag-cache";
+    mode: "nextMode";
+    private config;
+    private configLoaded;
+    private getConfig;
+    private buildTagKey;
+    getLastRevalidated(tags: string[]): Promise<number>;
+    hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
+    isStale(tags: string[], lastModified?: number): Promise<boolean>;
+    writeTags(tags: NextModeTagCacheWriteInput[]): Promise<void>;
+    private batchGetTags;
+    private batchWrite;
+}
+export {};

package/dist/overrides/tagCache/gateway.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Gateway Tag 缓存 Override (nextMode)
+ *
+ * 使用 OpenNext 的 nextMode 接口，通过 Gateway 代理读写 TableStore。
+ * 鉴权统一走 runtime/gateway-auth（HMAC 签名 + 4 header）。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const gateway_auth_1 = require("../../runtime/gateway-auth");
+const QUERY_TIMEOUT = 3000;
+const WRITE_TIMEOUT = 5000;
+const BATCH_SIZE = 200;
+function stripLeadingSlash(s) {
+    return s.replace(/^\/+/, '');
+}
+class GatewayTagCache {
+    constructor() {
+        this.name = 'gateway-tag-cache';
+        this.mode = 'nextMode';
+        this.config = null;
+        this.configLoaded = false;
+    }
+    getConfig() {
+        if (!this.configLoaded) {
+            this.config = (0, gateway_auth_1.loadGatewayAuthConfig)();
+            this.configLoaded = true;
+        }
+        return this.config;
+    }
+    buildTagKey(tag) {
+        const config = this.getConfig();
+        if (!config)
+            return tag;
+        return `${config.version}/${stripLeadingSlash(tag)}`;
+    }
+    async getLastRevalidated(tags) {
+        const config = this.getConfig();
+        if (!config)
+            return 0;
+        try {
+            const rows = await this.batchGetTags(config, tags);
+            let maxRevalidatedAt = 0;
+            for (const row of rows) {
+                if (row.revalidatedAt && row.revalidatedAt > maxRevalidatedAt) {
+                    maxRevalidatedAt = row.revalidatedAt;
+                }
+            }
+            return maxRevalidatedAt;
+        }
+        catch (err) {
+            console.warn(`[tagCache] getLastRevalidated error: ${err.message}`);
+            return 0;
+        }
+    }
+    async hasBeenRevalidated(tags, lastModified) {
+        const config = this.getConfig();
+        if (!config)
+            return false;
+        if (tags.length === 0)
+            return false;
+        try {
+            const rows = await this.batchGetTags(config, tags);
+            const now = Date.now();
+            const lm = lastModified !== null && lastModified !== void 0 ? lastModified : 0;
+            for (const row of rows) {
+                if (row.expire !== undefined) {
+                    if (row.expire <= now && row.expire > lm) {
+                        return true;
+                    }
+                }
+                if (row.revalidatedAt !== undefined && row.revalidatedAt > lm) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (err) {
+            console.warn(`[tagCache] hasBeenRevalidated error: ${err.message}`);
+            return false;
+        }
+    }
+    async isStale(tags, lastModified) {
+        var _a;
+        const config = this.getConfig();
+        if (!config)
+            return false;
+        if (tags.length === 0)
+            return false;
+        try {
+            const rows = await this.batchGetTags(config, tags);
+            const lm = lastModified !== null && lastModified !== void 0 ? lastModified : 0;
+            for (const row of rows) {
+                if (row.stale === undefined)
+                    continue;
+                const revalidatedAt = (_a = row.revalidatedAt) !== null && _a !== void 0 ? _a : 0;
+                if (revalidatedAt > lm && row.stale >= lm) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (err) {
+            console.warn(`[tagCache] isStale error: ${err.message}`);
+            return false;
+        }
+    }
+    async writeTags(tags) {
+        if (!tags || tags.length === 0)
+            return;
+        const config = this.getConfig();
+        if (!config)
+            return;
+        const writeTs = Date.now();
+        const rows = tags.map(input => {
+            const tagStr = typeof input === 'string' ? input : input.tag;
+            const stale = typeof input === 'string' ? undefined : input.stale;
+            const expire = typeof input === 'string' ? undefined : input.expire;
+            const tagKey = this.buildTagKey(tagStr);
+            const columns = [
+                { name: 'revalidatedAt', value: writeTs },
+            ];
+            if (stale !== undefined) {
+                columns.push({ name: 'stale', value: stale });
+            }
+            if (expire !== undefined) {
+                columns.push({ name: 'expire', value: expire });
+            }
+            return {
+                primaryKey: [
+                    { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },
+                    { name: 'tag', value: tagKey },
+                ],
+                columns,
+            };
+        });
+        await this.batchWrite(config, rows);
+    }
+    // ---- private methods ----
+    async batchGetTags(config, tags) {
+        const primaryKeys = tags.map(tag => [
+            { name: 'app_id', value: `${config.aliuid}/${config.routinename}` },
+            { name: 'tag', value: this.buildTagKey(tag) },
+        ]);
+        const res = await (0, gateway_auth_1.gatewayFetch)(config, '/table/batch-get-row', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ primaryKeys }),
+            timeoutMs: QUERY_TIMEOUT,
+        });
+        if (!res.ok) {
+            if (res.status === 401 || res.status === 403) {
+                console.error(`[tagCache] batch-get-row rejected (${res.status})`);
+            }
+            else {
+                console.warn(`[tagCache] batch-get-row failed: status=${res.status}`);
+            }
+            return [];
+        }
+        const data = (await res.json());
+        if (!data.rows)
+            return [];
+        return data.rows.map(row => {
+            var _a;
+            const result = {};
+            for (const col of (_a = row.columns) !== null && _a !== void 0 ? _a : []) {
+                if (col.name === 'revalidatedAt' && typeof col.value === 'number') {
+                    result.revalidatedAt = col.value;
+                }
+                else if (col.name === 'stale' && typeof col.value === 'number') {
+                    result.stale = col.value;
+                }
+                else if (col.name === 'expire' && typeof col.value === 'number') {
+                    result.expire = col.value;
+                }
+            }
+            return result;
+        });
+    }
+    async batchWrite(config, rows) {
+        if (rows.length === 0)
+            return;
+        for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+            const batch = rows.slice(i, i + BATCH_SIZE);
+            try {
+                const res = await (0, gateway_auth_1.gatewayFetch)(config, '/table/batch-write', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ rows: batch }),
+                    timeoutMs: WRITE_TIMEOUT,
+                });
+                if (res.status === 401 || res.status === 403) {
+                    console.error(`[tagCache] batch-write rejected (${res.status})`);
+                    return;
+                }
+                if (!res.ok) {
+                    console.warn(`[tagCache] batch-write failed: status=${res.status}`);
+                }
+            }
+            catch (err) {
+                if (err.name === 'AbortError') {
+                    console.warn(`[tagCache] batch-write timeout (${WRITE_TIMEOUT}ms)`);
+                }
+                else {
+                    console.warn(`[tagCache] batch-write error: ${err.message}`);
+                }
+            }
+        }
+    }
+}
+exports.default = GatewayTagCache;
+//# 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';\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"]}

package/dist/runtime/gateway-auth.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Gateway 鉴权共享客户端
+ *
+ * FC 端调 Gateway 的统一签名实现。所有 override 和 image-proxy 共用此 client，
+ * 确保签名算法与 Gateway 验证侧（src/middleware/jwt-auth.middleware.ts）一致。
+ *
+ * 算法：
+ *   authKey = HMAC-SHA256(secret, aliuid + routinename + version) → hex
+ *   md5Hash = MD5(authKey + expires + aliuid + routinename + version) → hex
+ *   Authorization = `${expires}-${md5Hash}`
+ *   expires = 毫秒时间戳
+ */
+export interface GatewayAuthConfig {
+    gatewayUrl: string;
+    secret: string;
+    aliuid: string;
+    routinename: string;
+    version: string;
+}
+export interface GatewaySignedHeaders {
+    authorization: string;
+    aliuid: string;
+    routinename: string;
+    version: string;
+}
+/**
+ * 从环境变量加载配置。缺必需变量返回 null + console.error，不抛。
+ *
+ * ESA runtime 直接注入以下 5 个 env：
+ *   - ESA_CACHE_GW_GATEWAY_ENDPOINT
+ *   - ESA_CACHE_GW_AUTH_KEY
+ *   - ESA_CACHE_GW_ALIUID
+ *   - ESA_CACHE_GW_ROUTINENAME
+ *   - ESA_CACHE_GW_VERSION
+ */
+export declare function loadGatewayAuthConfig(): GatewayAuthConfig | null;
+/**
+ * 算 Gateway 鉴权 4 header。每次请求重算 expires。
+ * 算法严格对齐 src/middleware/jwt-auth.middleware.ts:66-75。
+ */
+export declare function signGatewayHeaders(cfg: GatewayAuthConfig, ttlMs?: number): GatewaySignedHeaders;
+/**
+ * 自动注入签名 4 header 后 fetch；带超时控制（AbortController）。
+ *
+ * @param cfg loadGatewayAuthConfig() 返回值
+ * @param pathOrUrl 以 `/` 开头视为路径，与 cfg.gatewayUrl 拼接；否则视为完整 URL
+ * @param init RequestInit + 可选 timeoutMs
+ */
+export declare function gatewayFetch(cfg: GatewayAuthConfig, pathOrUrl: string, init?: RequestInit & {
+    timeoutMs?: number;
+}): Promise<Response>;

package/dist/runtime/gateway-auth.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Gateway 鉴权共享客户端
+ *
+ * FC 端调 Gateway 的统一签名实现。所有 override 和 image-proxy 共用此 client，
+ * 确保签名算法与 Gateway 验证侧（src/middleware/jwt-auth.middleware.ts）一致。
+ *
+ * 算法：
+ *   authKey = HMAC-SHA256(secret, aliuid + routinename + version) → hex
+ *   md5Hash = MD5(authKey + expires + aliuid + routinename + version) → hex
+ *   Authorization = `${expires}-${md5Hash}`
+ *   expires = 毫秒时间戳
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatewayFetch = exports.signGatewayHeaders = exports.loadGatewayAuthConfig = void 0;
+const crypto_1 = require("crypto");
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 5000;
+/**
+ * 使用未被 Next.js patch 的原始 fetch，避免 cache override 内部请求
+ * 被 Next.js 拦截导致递归死锁。延迟解析以允许测试环境 mock。
+ */
+function _fetch(input, init) {
+    var _a;
+    const fn = globalThis.__nextPatched
+        ? (_a = globalThis.__originalFetch) !== null && _a !== void 0 ? _a : globalThis.fetch
+        : globalThis.fetch;
+    return fn(input, init);
+}
+/**
+ * 从环境变量加载配置。缺必需变量返回 null + console.error，不抛。
+ *
+ * ESA runtime 直接注入以下 5 个 env：
+ *   - ESA_CACHE_GW_GATEWAY_ENDPOINT
+ *   - ESA_CACHE_GW_AUTH_KEY
+ *   - ESA_CACHE_GW_ALIUID
+ *   - ESA_CACHE_GW_ROUTINENAME
+ *   - ESA_CACHE_GW_VERSION
+ */
+function loadGatewayAuthConfig() {
+    const gatewayUrl = process.env.ESA_CACHE_GW_GATEWAY_ENDPOINT;
+    const secret = process.env.ESA_CACHE_GW_AUTH_KEY;
+    const aliuid = process.env.ESA_CACHE_GW_ALIUID;
+    const routinename = process.env.ESA_CACHE_GW_ROUTINENAME;
+    const version = process.env.ESA_CACHE_GW_VERSION;
+    const missing = [];
+    if (!gatewayUrl)
+        missing.push('ESA_CACHE_GW_GATEWAY_ENDPOINT');
+    if (!secret)
+        missing.push('ESA_CACHE_GW_AUTH_KEY');
+    if (!aliuid)
+        missing.push('ESA_CACHE_GW_ALIUID');
+    if (!routinename)
+        missing.push('ESA_CACHE_GW_ROUTINENAME');
+    if (!version)
+        missing.push('ESA_CACHE_GW_VERSION');
+    if (missing.length > 0) {
+        console.error(`[gateway-auth] 缺少必需的环境变量: ${missing.join(', ')}`);
+        return null;
+    }
+    return {
+        gatewayUrl: gatewayUrl.replace(/\/+$/, ''),
+        secret: secret,
+        aliuid: aliuid,
+        routinename: routinename,
+        version: version,
+    };
+}
+exports.loadGatewayAuthConfig = loadGatewayAuthConfig;
+/**
+ * 算 Gateway 鉴权 4 header。每次请求重算 expires。
+ * 算法严格对齐 src/middleware/jwt-auth.middleware.ts:66-75。
+ */
+function signGatewayHeaders(cfg, ttlMs = DEFAULT_TTL_MS) {
+    const expires = String(Date.now() + ttlMs);
+    const authKey = cfg.secret;
+    const md5Hash = (0, crypto_1.createHash)('md5')
+        .update(`${authKey}${expires}${cfg.aliuid}${cfg.routinename}${cfg.version}`)
+        .digest('hex');
+    return {
+        authorization: `${expires}-${md5Hash}`,
+        aliuid: cfg.aliuid,
+        routinename: cfg.routinename,
+        version: cfg.version,
+    };
+}
+exports.signGatewayHeaders = signGatewayHeaders;
+/**
+ * 自动注入签名 4 header 后 fetch；带超时控制（AbortController）。
+ *
+ * @param cfg loadGatewayAuthConfig() 返回值
+ * @param pathOrUrl 以 `/` 开头视为路径，与 cfg.gatewayUrl 拼接；否则视为完整 URL
+ * @param init RequestInit + 可选 timeoutMs
+ */
+async function gatewayFetch(cfg, pathOrUrl, init) {
+    var _a, _b;
+    const url = pathOrUrl.startsWith('/')
+        ? `${cfg.gatewayUrl}${pathOrUrl}`
+        : pathOrUrl;
+    const signed = signGatewayHeaders(cfg);
+    const headers = new Headers(init === null || init === void 0 ? void 0 : init.headers);
+    headers.set('Authorization', signed.authorization);
+    headers.set('AliUid', signed.aliuid);
+    headers.set('RoutineName', signed.routinename);
+    headers.set('Version', signed.version);
+    const timeoutMs = (_a = init === null || init === void 0 ? void 0 : init.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await _fetch(url, {
+            ...init,
+            headers,
+            signal: (_b = init === null || init === void 0 ? void 0 : init.signal) !== null && _b !== void 0 ? _b : controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+exports.gatewayFetch = gatewayFetch;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway-auth.js","sourceRoot":"","sources":["../../src/runtime/gateway-auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Gateway 鉴权共享客户端\n *\n * FC 端调 Gateway 的统一签名实现。所有 override 和 image-proxy 共用此 client，\n * 确保签名算法与 Gateway 验证侧（src/middleware/jwt-auth.middleware.ts）一致。\n *\n * 算法：\n *   authKey = HMAC-SHA256(secret, aliuid + routinename + version) → hex\n *   md5Hash = MD5(authKey + expires + aliuid + routinename + version) → hex\n *   Authorization = `${expires}-${md5Hash}`\n *   expires = 毫秒时间戳\n */\n\nimport { createHmac, createHash } from 'crypto';\n\nconst DEFAULT_TTL_MS = 5 * 60 * 1000;\nconst DEFAULT_TIMEOUT_MS = 5000;\n\nexport interface GatewayAuthConfig {\n  gatewayUrl: string;\n  secret: string;\n  aliuid: string;\n  routinename: string;\n  version: string;\n}\n\nexport interface GatewaySignedHeaders {\n  authorization: string;\n  aliuid: string;\n  routinename: string;\n  version: string;\n}\n\n/**\n * 使用未被 Next.js patch 的原始 fetch，避免 cache override 内部请求\n * 被 Next.js 拦截导致递归死锁。延迟解析以允许测试环境 mock。\n */\nfunction _fetch(\n  input: RequestInfo | URL,\n  init?: RequestInit\n): Promise<Response> {\n  const fn = (globalThis as any).__nextPatched\n    ? (globalThis as any).__originalFetch ?? globalThis.fetch\n    : globalThis.fetch;\n  return fn(input, init);\n}\n\n/**\n * 从环境变量加载配置。缺必需变量返回 null + console.error，不抛。\n *\n * ESA runtime 直接注入以下 5 个 env：\n *   - ESA_CACHE_GW_GATEWAY_ENDPOINT\n *   - ESA_CACHE_GW_AUTH_KEY\n *   - ESA_CACHE_GW_ALIUID\n *   - ESA_CACHE_GW_ROUTINENAME\n *   - ESA_CACHE_GW_VERSION\n */\nexport function loadGatewayAuthConfig(): GatewayAuthConfig | null {\n  const gatewayUrl = process.env.ESA_CACHE_GW_GATEWAY_ENDPOINT;\n  const secret = process.env.ESA_CACHE_GW_AUTH_KEY;\n  const aliuid = process.env.ESA_CACHE_GW_ALIUID;\n  const routinename = process.env.ESA_CACHE_GW_ROUTINENAME;\n  const version = process.env.ESA_CACHE_GW_VERSION;\n\n  const missing: string[] = [];\n  if (!gatewayUrl) missing.push('ESA_CACHE_GW_GATEWAY_ENDPOINT');\n  if (!secret) missing.push('ESA_CACHE_GW_AUTH_KEY');\n  if (!aliuid) missing.push('ESA_CACHE_GW_ALIUID');\n  if (!routinename) missing.push('ESA_CACHE_GW_ROUTINENAME');\n  if (!version) missing.push('ESA_CACHE_GW_VERSION');\n  if (missing.length > 0) {\n    console.error(`[gateway-auth] 缺少必需的环境变量: ${missing.join(', ')}`);\n    return null;\n  }\n\n  return {\n    gatewayUrl: gatewayUrl!.replace(/\\/+$/, ''),\n    secret: secret!,\n    aliuid: aliuid!,\n    routinename: routinename!,\n    version: version!,\n  };\n}\n\n/**\n * 算 Gateway 鉴权 4 header。每次请求重算 expires。\n * 算法严格对齐 src/middleware/jwt-auth.middleware.ts:66-75。\n */\nexport function signGatewayHeaders(\n  cfg: GatewayAuthConfig,\n  ttlMs: number = DEFAULT_TTL_MS\n): GatewaySignedHeaders {\n  const expires = String(Date.now() + ttlMs);\n  const authKey = cfg.secret;\n  const md5Hash = createHash('md5')\n    .update(`${authKey}${expires}${cfg.aliuid}${cfg.routinename}${cfg.version}`)\n    .digest('hex');\n  return {\n    authorization: `${expires}-${md5Hash}`,\n    aliuid: cfg.aliuid,\n    routinename: cfg.routinename,\n    version: cfg.version,\n  };\n}\n\n/**\n * 自动注入签名 4 header 后 fetch；带超时控制（AbortController）。\n *\n * @param cfg loadGatewayAuthConfig() 返回值\n * @param pathOrUrl 以 `/` 开头视为路径，与 cfg.gatewayUrl 拼接；否则视为完整 URL\n * @param init RequestInit + 可选 timeoutMs\n */\nexport async function gatewayFetch(\n  cfg: GatewayAuthConfig,\n  pathOrUrl: string,\n  init?: RequestInit & { timeoutMs?: number }\n): Promise<Response> {\n  const url = pathOrUrl.startsWith('/')\n    ? `${cfg.gatewayUrl}${pathOrUrl}`\n    : pathOrUrl;\n\n  const signed = signGatewayHeaders(cfg);\n  const headers = new Headers(init?.headers);\n  headers.set('Authorization', signed.authorization);\n  headers.set('AliUid', signed.aliuid);\n  headers.set('RoutineName', signed.routinename);\n  headers.set('Version', signed.version);\n\n  const timeoutMs = init?.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n\n  try {\n    return await _fetch(url, {\n      ...init,\n      headers,\n      signal: init?.signal ?? controller.signal,\n    });\n  } finally {\n    clearTimeout(timer);\n  }\n}\n"]}