data-preheating-astro 0.1.1

package/README.md

@@ -0,0 +1,40 @@
+# Strapi Content Exporter
+
+本项目用于从 Strapi REST API **并发**拉取模块数据，对富文本做“关键词 → 内链”的严格替换处理，并将结果落盘到 `data/` 目录。
+
+## 特性
+
+- **并发拉取**：完成一个请求就立刻补下一个，保持并发池满载，尽快拉取全量分页数据。
+- **接口级国际化**：每个模块可配置是否启用 i18n；启用时按语言列表分别拉取并输出到 `data/[lang]/...`。
+- **富文本严格内链**：仅处理 HTML 文本节点；对每个关键词做“出现次数 vs 生成链接次数”的严格校验，避免遗漏。
+- **输出结构**：
+  - 单语言：`data/shared/[modules]/index.json`
+  - 多语言：`data/[lang]/[modules]/index.json`
+  - 富文本：`data/**/[modules]/[slug].[field].html`
+
+## 环境变量
+
+所有环境变量均可不设置，项目会使用默认值；但当存在启用 i18n 的模块时，建议明确设置语言列表。
+
+- `EXPORT_BASE_URL`：Strapi 基础地址，例如 `https://example.com`
+- `EXPORT_API_TOKEN`：可选，若接口需要鉴权则使用 `Authorization: Bearer ...`
+- `EXPORT_MAX_CONCURRENCY`：最大并发数，默认 `50`
+- `EXPORT_FAIL_STRATEGY`：失败策略，默认 `fail_fast`；可选 `continue`
+- `EXPORT_LANGS`：多语言列表，例如 `en,zh-Hans`（仅在模块启用 i18n 时使用）
+- `EXPORT_DEFAULT_LANG`：默认语言，默认 `en`
+- `EXPORT_OUTPUT_DIR`：输出目录，默认 `data`
+
+## 运行
+
+安装依赖后执行：
+
+```bash
+npm i
+npm run build
+npm run start
+```
+
+## 模块配置
+
+在 `src/config/modules/` 下为每个 Strapi 接口创建一个模块配置文件，并在 `src/config/app.config.ts` 中引入。
+

package/dist/apis/paginate.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * 并发分页调度（核心）。
+ *
+ * 目的：
+ * - “全量拉取”通常需要分页；为了尽快完成全量拉取，这里实现一个并发调度器：
+ *   完成一个请求就立刻补下一个，保持并发池尽量满载。
+ *
+ * 说明：
+ * - 该文件不限制你只能拉取部分数据；它的目标是让“全量分页拉取”更快完成。
+ * - 这里不考虑限流与优化策略，保持实现简洁，重点是吞吐。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncPool = void 0;
+/**
+ * 一个最小的并发任务池。
+ * - 支持任务在执行过程中继续 add 新任务（用于分页任务动态补位）。
+ */
+class AsyncPool {
+    maxConcurrency;
+    failStrategy;
+    queue = [];
+    running = 0;
+    idleResolvers = [];
+    idleRejecters = [];
+    stopped = false;
+    firstError = null;
+    errors = [];
+    constructor(opts) {
+        this.maxConcurrency = opts.maxConcurrency;
+        this.failStrategy = opts.failStrategy;
+    }
+    /**
+     * 添加一个任务。
+     */
+    add(task) {
+        if (this.stopped)
+            return;
+        this.queue.push(task);
+        this.drain();
+    }
+    /**
+     * 等待池进入空闲（所有任务执行完成，且队列为空）。
+     */
+    waitIdle() {
+        if (this.firstError && this.failStrategy === "fail_fast") {
+            return Promise.reject(this.firstError);
+        }
+        if (this.queue.length === 0 && this.running === 0) {
+            return Promise.resolve({ errors: this.errors });
+        }
+        return new Promise((resolve, reject) => {
+            this.idleResolvers.push(() => resolve({ errors: this.errors }));
+            this.idleRejecters.push(reject);
+        });
+    }
+    drain() {
+        while (!this.stopped && this.running < this.maxConcurrency && this.queue.length > 0) {
+            const task = this.queue.shift();
+            if (!task)
+                break;
+            this.running += 1;
+            Promise.resolve()
+                .then(task)
+                .catch((err) => this.onError(err))
+                .finally(() => {
+                this.running -= 1;
+                this.drain();
+                this.maybeResolveIdle();
+            });
+        }
+    }
+    onError(err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        this.errors.push(e);
+        if (!this.firstError) {
+            this.firstError = e;
+        }
+        if (this.failStrategy === "fail_fast") {
+            this.stopped = true;
+            this.rejectIdle(e);
+        }
+    }
+    maybeResolveIdle() {
+        if (this.stopped)
+            return;
+        if (this.queue.length !== 0)
+            return;
+        if (this.running !== 0)
+            return;
+        const resolvers = this.idleResolvers;
+        this.idleResolvers = [];
+        this.idleRejecters = [];
+        resolvers.forEach((r) => r());
+    }
+    rejectIdle(err) {
+        const rejecters = this.idleRejecters;
+        this.idleResolvers = [];
+        this.idleRejecters = [];
+        rejecters.forEach((r) => r(err));
+    }
+}
+exports.AsyncPool = AsyncPool;

package/dist/apis/query.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Strapi 查询参数序列化。
+ *
+ * 说明：
+ * - Strapi 参数经常包含深层对象（populate/filters/fields/sort/pagination 等）。
+ * - 使用 qs 将 object 序列化为查询字符串，便于模块配置“以对象维护参数”。
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toQueryString = toQueryString;
+const qs_1 = __importDefault(require("qs"));
+function toQueryString(params) {
+    const query = qs_1.default.stringify(params, {
+        encodeValuesOnly: true,
+        arrayFormat: "indices"
+    });
+    return query ? `?${query}` : "";
+}

package/dist/apis/request.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * HTTP 请求封装（用于 Strapi）。
+ *
+ * 说明：
+ * - 这里提供最小封装：超时、JSON 解析、错误包装、可选鉴权。
+ * - 不做复杂优化逻辑，保持简单直观。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initHttpClient = initHttpClient;
+exports.fetchJson = fetchJson;
+/**
+ * 初始化 undici 连接池（底层并发能力）。
+ *
+ * 说明：
+ * - Node 的 fetch 底层使用 undici，并且对同一 origin 的连接数存在默认上限
+ * - 当导出并发很高（例如 50）时，默认上限会让大量请求在客户端排队，从而整体变慢
+ * - 这里在程序启动时把连接池上限提升到与导出并发一致，尽量避免“假并发”
+ *
+ * 注意：
+ * - 该实现不引入任何依赖；运行时若无法加载 undici，则直接跳过（不影响功能）
+ * - 只需要调用一次；重复调用会被忽略
+ */
+let httpClientInited = false;
+let undiciFetch = null;
+let undiciAgent = null;
+function initHttpClient(params) {
+    if (httpClientInited)
+        return;
+    httpClientInited = true;
+    // connections 取整并做下限保护，避免传入非法值导致抛错。
+    const n = Number.isFinite(params.connections) ? Math.floor(params.connections) : 0;
+    const connections = Math.max(1, n);
+    try {
+        // 使用 require 避免 TypeScript 依赖 undici 类型声明（保持代码最简）。
+        const undici = require("undici");
+        if (!undici || typeof undici.Agent !== "function" || typeof undici.fetch !== "function") {
+            return;
+        }
+        // 保存 fetch + agent，后续请求强制走 undici.fetch + dispatcher，确保连接池配置生效。
+        undiciFetch = undici.fetch;
+        undiciAgent = new undici.Agent({ connections });
+    }
+    catch {
+        // 若运行环境无法加载 undici，则不做任何处理（保持功能正常）。
+    }
+}
+/**
+ * 请求 JSON 并返回解析后的对象。
+ */
+async function fetchJson(ctx, pathWithQuery) {
+    const url = new URL(pathWithQuery, ctx.baseUrl).toString();
+    const startedAt = Date.now();
+    let logged = false;
+    function emitLog(info) {
+        if (!ctx.onHttpLog)
+            return;
+        logged = true;
+        ctx.onHttpLog({
+            ts: new Date().toISOString(),
+            method: "GET",
+            url,
+            pathWithQuery,
+            ok: info.ok,
+            status: info.status,
+            durationMs: Math.max(0, Date.now() - startedAt),
+            error: info.error
+        });
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), ctx.timeoutMs);
+    try {
+        const headers = {
+            Accept: "application/json"
+        };
+        if (ctx.apiToken) {
+            headers.Authorization = `Bearer ${ctx.apiToken}`;
+        }
+        /**
+         * 请求发起：
+         * - 若已初始化 undici agent，则使用 undici.fetch 并显式传 dispatcher，确保连接池配置生效
+         * - 否则回退到全局 fetch（保持兼容）
+         */
+        const useUndici = typeof undiciFetch === "function" && undiciAgent;
+        const res = useUndici
+            ? await undiciFetch(url, {
+                method: "GET",
+                headers,
+                signal: controller.signal,
+                dispatcher: undiciAgent
+            })
+            : await fetch(url, {
+                method: "GET",
+                headers,
+                signal: controller.signal
+            });
+        if (!res.ok) {
+            const text = await safeReadText(res);
+            // 非 2xx：记录一次请求失败（带 status），避免后续 catch 重复记录。
+            emitLog({ ok: false, status: res.status, error: `HTTP ${res.status} ${res.statusText}` });
+            throw new Error(`请求失败：${res.status} ${res.statusText} ${text}`);
+        }
+        const json = (await res.json());
+        emitLog({ ok: true, status: res.status });
+        return json;
+    }
+    catch (err) {
+        // 异常也要上报（例如超时/网络失败/JSON 解析失败）。
+        if (!logged) {
+            emitLog({ ok: false, error: err instanceof Error ? err.message : String(err) });
+        }
+        throw wrapError(err, `请求异常：${url}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function safeReadText(res) {
+    try {
+        const t = await res.text();
+        return t ? `- ${t.slice(0, 500)}` : "";
+    }
+    catch {
+        return "";
+    }
+}
+function wrapError(err, msg) {
+    if (err instanceof Error) {
+        return new Error(`${msg} - ${err.message}`);
+    }
+    return new Error(`${msg} - ${String(err)}`);
+}

package/dist/cache/keywordHitCache.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * 关键词命中缓存（用于富文本内链提速）。
+ *
+ * 目标：
+ * - 每天首次运行：用全量关键词规则做内链，并把“每条富文本实际命中的关键词列表”保存下来
+ * - 同一天后续运行：直接使用命中的关键词子集做内链，减少 1-2 千关键词逐个匹配带来的耗时
+ *
+ * 说明：
+ * - 缓存文件写入到项目根目录下的 `.cache/`（不放在 data 目录内）
+ * - 实现保持简单：按天失效（不做更复杂的版本/哈希策略）
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeywordHitStore = createKeywordHitStore;
+exports.getTodayKey = getTodayKey;
+exports.keywordRulesCacheFilePath = keywordRulesCacheFilePath;
+exports.loadKeywordRulesCache = loadKeywordRulesCache;
+exports.saveKeywordRulesCache = saveKeywordRulesCache;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const output_1 = require("../write/output");
+/**
+ * 创建按文章维度的关键词命中存储器。
+ *
+ * 目录结构：
+ * - .cache/keyword-hits/<lang>/<module>/<file>.json
+ *
+ * file 命名尽量可读，同时做必要的字符清洗以保证跨平台文件名安全。
+ */
+function createKeywordHitStore(params) {
+    const langSafe = safeName(params.lang || "default");
+    const baseDir = node_path_1.default.join(params.cacheDirAbs, "keyword-hits", langSafe);
+    function entryFilePath(moduleName, slug, fieldPath) {
+        const modSafe = safeName(moduleName || "unknown");
+        const slugSafe = safeName(slug || "unknown");
+        const fieldSafe = safeName(fieldPath || "richtext");
+        // 文件名：slug.field.json（保持尽量可读）
+        const file = `${slugSafe}.${fieldSafe}.json`;
+        return node_path_1.default.join(baseDir, modSafe, file);
+    }
+    async function readEntry(filePath) {
+        try {
+            const text = await node_fs_1.promises.readFile(filePath, "utf8");
+            const parsed = JSON.parse(text);
+            if (parsed.version !== 1)
+                return null;
+            if (typeof parsed.day !== "string")
+                return null;
+            if (!Array.isArray(parsed.keywords))
+                return null;
+            return { version: 1, day: parsed.day, keywords: parsed.keywords };
+        }
+        catch {
+            return null;
+        }
+    }
+    return {
+        async get({ moduleName, slug, fieldPath }) {
+            await (0, output_1.ensureDir)(baseDir);
+            const p = entryFilePath(moduleName, slug, fieldPath);
+            const v = await readEntry(p);
+            if (!v)
+                return undefined;
+            // 按天失效：不是今天直接视为不存在（保持实现简单）。
+            if (v.day !== getTodayKey())
+                return undefined;
+            return v.keywords;
+        },
+        async setIfAbsent({ moduleName, slug, fieldPath, keywords }) {
+            await (0, output_1.ensureDir)(baseDir);
+            const p = entryFilePath(moduleName, slug, fieldPath);
+            const existing = await readEntry(p);
+            if (existing && existing.day === getTodayKey())
+                return;
+            // 写入前确保模块目录存在
+            await (0, output_1.ensureDir)(node_path_1.default.dirname(p));
+            const data = {
+                version: 1,
+                day: getTodayKey(),
+                keywords: Array.isArray(keywords) ? keywords : []
+            };
+            await (0, output_1.writeJsonAtomic)(p, data);
+        }
+    };
+}
+/**
+ * 文件名安全化（尽量简单）。
+ *
+ * 说明：
+ * - 替换掉路径分隔符与特殊字符，避免生成不可用文件名
+ * - 不做复杂编码，保持可读性为主
+ */
+function safeName(s) {
+    const v = typeof s === "string" ? s.trim() : "";
+    const out = v.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/_+/g, "_");
+    // 避免超长文件名（保持简单，截断即可）
+    return out.length > 120 ? out.slice(0, 120) : out || "unknown";
+}
+/**
+ * 获取今天日期（本地时区）的 YYYY-MM-DD 字符串。
+ */
+function getTodayKey() {
+    const d = new Date();
+    const pad2 = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+/**
+ * 构建关键词接口缓存文件路径：.cache/keywords-items.<lang>.json
+ */
+function legacyKeywordApiItemsCacheFilePath(cacheDirAbs, lang) {
+    const safeLang = (lang || "default").replace(/[^a-zA-Z0-9._-]/g, "_");
+    return node_path_1.default.join(cacheDirAbs, `keywords-items.${safeLang}.json`);
+}
+/**
+ * 构建关键词规则缓存文件路径：.cache/keyword-rules.<lang>.json
+ */
+function keywordRulesCacheFilePath(cacheDirAbs, lang) {
+    const safeLang = (lang || "default").replace(/[^a-zA-Z0-9._-]/g, "_");
+    return node_path_1.default.join(cacheDirAbs, `keyword-rules.${safeLang}.json`);
+}
+/**
+ * 加载关键词接口缓存；若不存在或非今天则返回 null。
+ *
+ * 说明：
+ * - 用于“同一天后续运行不再请求 keywords 接口”的需求
+ */
+async function loadKeywordRulesCache(params) {
+    await (0, output_1.ensureDir)(params.cacheDirAbs);
+    const today = getTodayKey();
+    // 1) 优先读取新缓存（keyword-rules.*.json）
+    const rulesPath = keywordRulesCacheFilePath(params.cacheDirAbs, params.lang);
+    try {
+        const text = await node_fs_1.promises.readFile(rulesPath, "utf8");
+        const parsed = JSON.parse(text);
+        if (parsed.version !== 1)
+            return null;
+        // 用户要求：当天首次正常请求并缓存；当天后续只读缓存，不再请求（因此按“当天”判断）
+        if (typeof parsed.day !== "string" || parsed.day !== today)
+            return null;
+        if (!Array.isArray(parsed.rules))
+            return null;
+        return parsed.rules;
+    }
+    catch {
+        // 无新缓存：继续尝试旧缓存迁移
+    }
+    /**
+     * 2) 兼容旧缓存（keywords-items.*.json）并自动迁移。
+     *
+     * 说明：
+     * - 旧文件体积大，迁移后会删除旧文件，避免目录膨胀
+     * - 迁移只做“字段裁剪”，不改变规则含义
+     */
+    const legacyPath = legacyKeywordApiItemsCacheFilePath(params.cacheDirAbs, params.lang);
+    try {
+        const text = await node_fs_1.promises.readFile(legacyPath, "utf8");
+        const parsed = JSON.parse(text);
+        if (parsed?.version !== 1)
+            return null;
+        // 同上：只在“当天”迁移并使用，避免跨天读取旧规则
+        if (typeof parsed?.day !== "string" || parsed.day !== today)
+            return null;
+        if (!Array.isArray(parsed?.items))
+            return null;
+        const rules = [];
+        for (const raw of parsed.items) {
+            const keyword = typeof raw?.keyword === "string" ? raw.keyword.trim() : "";
+            const href = typeof raw?.slug === "string" ? raw.slug.trim() : "";
+            if (!keyword || !href)
+                continue;
+            rules.push({ keyword, href });
+        }
+        // 写入新缓存并删除旧缓存（删除失败不影响流程）。
+        await saveKeywordRulesCache({ cacheDirAbs: params.cacheDirAbs, lang: params.lang, rules, day: today });
+        try {
+            await node_fs_1.promises.rm(legacyPath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        return rules;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 保存关键词规则缓存（覆盖写入）。
+ */
+async function saveKeywordRulesCache(params) {
+    await (0, output_1.ensureDir)(params.cacheDirAbs);
+    const filePath = keywordRulesCacheFilePath(params.cacheDirAbs, params.lang);
+    const data = {
+        version: 1,
+        day: (params.day || getTodayKey()).trim() || getTodayKey(),
+        rules: params.rules
+    };
+    await (0, output_1.writeJsonAtomic)(filePath, data);
+}