@taicode/common-server 3.8.0 → 4.0.0-beta.10

package/output/app/define-server.js

@@ -1,289 +0,0 @@
-import { Disposer } from '@taicode/common-base';
-import Fastify, {} from 'fastify';
-import { assembleModules } from './assemble.js';
-import { attachSignalHandlers } from './signal.js';
-import { SHUTDOWN_ORDER } from './shutdown.js';
-import { SKIP_BY_MODE, STEP_ORDER } from './steps.js';
-const NOOP_LOGGER = {
-    debug: () => undefined,
-    info: () => undefined,
-    warn: () => undefined,
-    error: () => undefined,
-};
-function requireApp(state) {
-    if (!state.app) {
-        throw new Error('Fastify instance has not been created yet');
-    }
-    return state.app;
-}
-function resolveLog(options, state) {
-    if (options.log) {
-        return options.log;
-    }
-    if (state.app) {
-        return state.app.log;
-    }
-    return NOOP_LOGGER;
-}
-function collectHooks(resolved) {
-    const hooks = {};
-    for (const name of resolved.order) {
-        const module = resolved.byName[name];
-        if (module?.hooks) {
-            Object.assign(hooks, module.hooks);
-        }
-    }
-    return hooks;
-}
-function collectPlugins(resolved, options) {
-    const plugins = [];
-    for (const name of resolved.order) {
-        const module = resolved.byName[name];
-        if (module?.plugins) {
-            plugins.push(...module.plugins);
-        }
-    }
-    if (options.extraPlugins) {
-        plugins.push(...options.extraPlugins);
-    }
-    return plugins;
-}
-function buildStepImplementations(resolved, options, moduleHooks) {
-    const implementations = {};
-    // 1) 固定骨架步骤的内置实现（模块可覆盖既定槽位，但无法新增 / 重排步骤）
-    implementations.createFastify = (ctx) => {
-        ctx.state.app = Fastify({ logger: ctx.options.config.loadConfig().debug, trustProxy: true });
-    };
-    implementations.registerCorePlugins = async (ctx) => {
-        const app = requireApp(ctx.state);
-        for (const plugin of collectPlugins(resolved, ctx.options)) {
-            await app.register(plugin);
-        }
-    };
-    implementations.onClose = (ctx) => {
-        const shutdownImplementations = buildShutdownImplementations(resolved, moduleHooks);
-        requireApp(ctx.state).addHook('onClose', () => runShutdown(ctx, shutdownImplementations, moduleHooks));
-    };
-    implementations.ready = async (ctx) => {
-        await requireApp(ctx.state).ready();
-    };
-    implementations.listen = async (ctx) => {
-        const app = requireApp(ctx.state);
-        const host = ctx.options.serverOptions?.host ?? '0.0.0.0';
-        const port = ctx.options.serverOptions?.port ?? ctx.options.config.loadConfig().port;
-        await app.listen({ port, host });
-        if (ctx.options.signal !== false) {
-            attachSignalHandlers(app, ctx.log);
-        }
-    };
-    // 2) 数据层端口 → 第 3 步（database 模块的整体覆盖也在此生效）
-    const database = resolved.database;
-    if (database) {
-        implementations['database.createClient'] = async (ctx) => {
-            const loadPostgresConfig = ctx.options.config.loadPostgresConfig;
-            const postgresConfig = loadPostgresConfig ? await loadPostgresConfig() : undefined;
-            ctx.state.db = await database.createClient({ config: ctx.options.config, postgresConfig });
-        };
-    }
-    // 3) 模块贡献的步骤实现（注册顺序 = MODULE_NAMES 顺序）
-    for (const name of resolved.order) {
-        const module = resolved.byName[name];
-        if (module?.steps) {
-            Object.assign(implementations, module.steps);
-        }
-    }
-    // 4) 调用方槽位（调用方优先级最高）
-    if (options.setupCompilers) {
-        implementations.setupCompilers = (ctx) => {
-            ctx.options.setupCompilers?.(requireApp(ctx.state));
-        };
-    }
-    if (options.initGlobalConfig) {
-        implementations.initGlobalConfig = (ctx) => {
-            const globalConfigOptions = {
-                redisUrl: ctx.options.config.resolveRedisUrl?.(),
-                channelPrefix: ctx.options.config.resolveCachePrefix?.(),
-            };
-            const dispose = ctx.options.initGlobalConfig?.(ctx.state.db, globalConfigOptions);
-            if (typeof dispose === 'function') {
-                ctx.state.disposeConfig = dispose;
-            }
-        };
-    }
-    if (options.initClients) {
-        implementations.initClients = async (ctx) => {
-            const unsubscribe = await ctx.options.initClients?.({
-                db: ctx.state.db,
-                redis: ctx.state.redis?.client,
-                globalConfig: ctx.state.globalConfig,
-            });
-            if (typeof unsubscribe === 'function') {
-                ctx.state.unsubscribe = unsubscribe;
-            }
-        };
-    }
-    implementations.createServices = (ctx) => {
-        ctx.state.services = ctx.options.createServices({
-            db: ctx.state.db,
-            redis: ctx.state.redis?.client,
-            globalConfig: ctx.state.globalConfig,
-        });
-    };
-    if (options.initServices || options.afterInit) {
-        implementations.initServices = async (ctx) => {
-            if (ctx.options.initServices) {
-                await ctx.options.initServices({ services: ctx.state.services });
-            }
-            if (ctx.options.afterInit) {
-                const disposer = await ctx.options.afterInit({
-                    db: ctx.state.db,
-                    redis: ctx.state.redis?.client,
-                    globalConfig: ctx.state.globalConfig,
-                    services: ctx.state.services,
-                });
-                if (typeof disposer === 'function') {
-                    ctx.state.disposer.addDisposer(disposer);
-                }
-            }
-        };
-    }
-    if (options.backgroundWorkers) {
-        implementations.backgroundWorkers = async (ctx) => {
-            await ctx.options.backgroundWorkers?.({
-                db: ctx.state.db,
-                redis: ctx.state.redis?.client,
-                globalConfig: ctx.state.globalConfig,
-                services: ctx.state.services,
-                disposer: ctx.state.disposer,
-            });
-        };
-    }
-    implementations.registerRouters = async (ctx) => {
-        await ctx.options.registerRouters(requireApp(ctx.state), { services: ctx.state.services });
-    };
-    if (options.afterReady) {
-        implementations.afterReady = async (ctx) => {
-            await ctx.options.afterReady?.({ app: requireApp(ctx.state), services: ctx.state.services });
-        };
-    }
-    return implementations;
-}
-async function disposeServiceMap(services) {
-    if (typeof services !== 'object' || services === null) {
-        return;
-    }
-    const record = services;
-    const pending = Object.values(record).map((service) => {
-        const candidate = service;
-        return typeof candidate.dispose === 'function' ? candidate.dispose() : undefined;
-    });
-    await Promise.allSettled(pending);
-}
-function buildShutdownImplementations(resolved, moduleHooks) {
-    const implementations = {
-        stopProducers: async (ctx) => {
-            await ctx.state.disposer.dispose();
-        },
-        unsubscribeConfig: async (ctx) => {
-            await ctx.state.unsubscribe?.();
-        },
-        disposeConfig: async (ctx) => {
-            await ctx.state.disposeConfig?.();
-        },
-        disposeServices: async (ctx) => {
-            const disposeServices = ctx.options.disposeServices ?? moduleHooks.disposeServices;
-            if (disposeServices) {
-                await disposeServices({ services: ctx.state.services });
-            }
-            else {
-                await disposeServiceMap(ctx.state.services);
-            }
-        },
-        disposeClients: async (ctx) => {
-            const disposeClients = ctx.options.disposeClients ?? moduleHooks.disposeClients;
-            await disposeClients?.();
-        },
-        disposeRedis: async (ctx) => {
-            await ctx.state.redis?.dispose();
-        },
-        disposeDb: async (ctx) => {
-            await resolved.database?.dispose?.(ctx.state.db);
-        },
-    };
-    for (const name of resolved.order) {
-        const module = resolved.byName[name];
-        if (module?.shutdown) {
-            Object.assign(implementations, module.shutdown);
-        }
-    }
-    return implementations;
-}
-async function runShutdown(ctx, implementations, moduleHooks) {
-    const errors = [];
-    const options = ctx.options;
-    const shutdown = options.shutdown ?? moduleHooks.shutdown;
-    const beforeShutdown = options.beforeShutdown ?? moduleHooks.beforeShutdown;
-    if (shutdown) {
-        try {
-            await shutdown('onClose');
-        }
-        catch (error) {
-            errors.push(error);
-        }
-    }
-    else {
-        if (beforeShutdown) {
-            try {
-                await beforeShutdown();
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-        for (const step of SHUTDOWN_ORDER) {
-            const implementation = implementations[step];
-            if (!implementation) {
-                continue;
-            }
-            try {
-                await implementation(ctx);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-    }
-    if (errors.length > 0) {
-        ctx.log.error({ errors, count: errors.length }, '[shutdown] completed with errors');
-    }
-}
-/**
- * 模块化装配 + 15 步固定编排（design §3 / §4 / §5；提案 §11）。
- *
- * 返回**原生 `FastifyInstance`**（不包 `fastify-plugin`、不返回包装对象）——调用方可直接
- * `app.swagger()` / `app.inject()` / `app.decorate()`。`mode: 'openapi-build'` 时不 listen，
- * 由调用方读 `app.swagger()`。
- *
- * `Db` 由 `modules.database`（`database` 模块的 `createClient` 返回类型）推断（决策 10-2）。
- */
-export async function defineServer(options) {
-    const internal = options;
-    const mode = internal.mode ?? 'production';
-    const resolved = assembleModules(internal.modules);
-    const state = { disposer: new Disposer() };
-    const moduleHooks = collectHooks(resolved);
-    const implementations = buildStepImplementations(resolved, internal, moduleHooks);
-    const skipped = new Set(SKIP_BY_MODE[mode]);
-    for (const step of STEP_ORDER) {
-        if (skipped.has(step)) {
-            continue;
-        }
-        const ctx = { options: internal, state, log: resolveLog(internal, state) };
-        ctx.log.debug({ step }, '[boot]');
-        const implementation = implementations[step];
-        if (implementation) {
-            await implementation(ctx);
-        }
-    }
-    return requireApp(state);
-}

package/output/app/define-server.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=define-server.test.d.ts.map

package/output/app/define-server.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"define-server.test.d.ts","sourceRoot":"","sources":["../../source/app/define-server.test.ts"],"names":[],"mappings":""}

package/output/app/define-server.test.js

@@ -1,299 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest';
-import { createPrismaDatabaseModule } from './database.js';
-import { defineServer } from './define-server.js';
-import { STEP_ORDER } from './steps.js';
-const P1_OPT_OUT = {
-    context: false,
-    response: false,
-    cors: false,
-    schema: false,
-    'rate-limit': false,
-    auth: false,
-    openapi: false,
-    database: false,
-};
-const DUMMY_ERRORS = {
-    UserError: class extends Error {
-    },
-    SystemError: class extends Error {
-    },
-};
-const TEST_CONFIG = { loadConfig: () => ({ debug: false, port: 0 }) };
-const FAKE_PRISMA_NAMESPACE = {
-    PrismaClientKnownRequestError: class extends Error {
-    },
-    PrismaClientUnknownRequestError: class extends Error {
-    },
-    PrismaClientValidationError: class extends Error {
-    },
-    PrismaClientRustPanicError: class extends Error {
-    },
-    PrismaClientInitializationError: class extends Error {
-    },
-};
-class FakeClient {
-    args;
-    disconnected = false;
-    constructor(args = []) {
-        this.args = args;
-    }
-    async $disconnect() {
-        this.disconnected = true;
-    }
-}
-function createTestLog() {
-    const steps = [];
-    const errors = [];
-    const log = {
-        debug: (obj) => {
-            const step = obj.step;
-            if (typeof step === 'string') {
-                steps.push(step);
-            }
-        },
-        info: () => undefined,
-        warn: () => undefined,
-        error: (obj) => {
-            errors.push(obj);
-        },
-    };
-    return { log, steps, errors };
-}
-function without(list, drop) {
-    return list.filter((step) => !drop.includes(step));
-}
-function createBaseOptions(overrides = {}) {
-    return {
-        serviceName: 'test',
-        title: 'Test',
-        description: 'Test service',
-        errors: DUMMY_ERRORS,
-        config: TEST_CONFIG,
-        modules: { ...P1_OPT_OUT },
-        serverOptions: { port: 0, host: '127.0.0.1' },
-        signal: false,
-        createServices: () => ({ dispose: () => undefined }),
-        registerRouters: () => undefined,
-        ...overrides,
-    };
-}
-describe('defineServer 装配期校验', () => {
-    it('未知模块名报错（文案逐字对齐 design §3.2）', async () => {
-        const modules = { ...P1_OPT_OUT, foo: false };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Unknown module "foo". Allowed: env, database, redis, context, response, cors, schema, rate-limit, auth, openapi');
-    });
-    it('重复注册报错', async () => {
-        const modules = { ...P1_OPT_OUT, cors: { name: 'cors' }, redis: { name: 'cors' } };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "cors" registered twice');
-    });
-    it('键名不符报错', async () => {
-        const modules = { ...P1_OPT_OUT, redis: { name: 'mysql' } };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module key "redis" != module.name "mysql"');
-    });
-    it('dependsOn 指向被跳过的模块报错', async () => {
-        const modules = {
-            ...P1_OPT_OUT,
-            database: false,
-            redis: { name: 'redis', dependsOn: ['database'] },
-        };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "redis" depends on "database" which is disabled');
-    });
-    it('P1 未实现模块未显式 false 报错', async () => {
-        const modules = {
-            context: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            auth: false,
-            openapi: false,
-            database: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "response" is not implemented until P3; pass false to opt out');
-    });
-    it('过渡期报错按真实阶段号：openapi = P2、auth = P4', async () => {
-        const modulesWithoutOpenapi = {
-            context: false,
-            response: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            auth: false,
-            database: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules: modulesWithoutOpenapi }))).rejects.toThrow('Module "openapi" is not implemented until P2; pass false to opt out');
-        const modulesWithoutAuth = {
-            context: false,
-            response: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            openapi: false,
-            database: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules: modulesWithoutAuth }))).rejects.toThrow('Module "auth" is not implemented until P4; pass false to opt out');
-    });
-    it('未显式提供 database 报错（提示需 createPrismaDatabaseModule({...}) 或 false）', async () => {
-        const modules = {
-            context: false,
-            response: false,
-            cors: false,
-            schema: false,
-            'rate-limit': false,
-            auth: false,
-            openapi: false,
-        };
-        await expect(defineServer(createBaseOptions({ modules }))).rejects.toThrow('Module "database" requires createPrismaDatabaseModule({...}) or false');
-    });
-    it('装配期报错发生在 promise resolve 之前（不拖到 listen）', async () => {
-        const promise = defineServer(createBaseOptions({ modules: { ...P1_OPT_OUT, database: false, redis: { name: 'redis', dependsOn: ['database'] } } }));
-        await expect(promise).rejects.toThrow();
-    });
-});
-describe('defineServer 15 步骨架', () => {
-    it('production 模式执行完整 15 步且顺序固定', async () => {
-        const { log, steps } = createTestLog();
-        const app = await defineServer(createBaseOptions({ log, mode: 'production' }));
-        try {
-            expect(steps).toEqual([...STEP_ORDER]);
-        }
-        finally {
-            await app.close();
-        }
-    });
-    it('test 模式跳过第 10 / 14 步', async () => {
-        const { log, steps } = createTestLog();
-        const app = await defineServer(createBaseOptions({ log, mode: 'test' }));
-        try {
-            expect(steps).toEqual(without(STEP_ORDER, ['backgroundWorkers', 'afterReady']));
-        }
-        finally {
-            await app.close();
-        }
-    });
-    it('openapi-build 模式跳过 [5,6,9,10,14,15]，但保留第 3 / 4 步（决策 10-3）', async () => {
-        const { log, steps } = createTestLog();
-        const app = await defineServer(createBaseOptions({ log, mode: 'openapi-build' }));
-        expect(steps).toEqual(without(STEP_ORDER, ['initGlobalConfig', 'initClients', 'initServices', 'backgroundWorkers', 'afterReady', 'listen']));
-        expect(steps).toContain('database.createClient');
-        expect(steps).toContain('createRedis');
-        await app.close();
-    });
-});
-describe('defineServer 跳过语义', () => {
-    it('test 模式下 backgroundWorkers / afterReady 确实未执行', async () => {
-        let workers = 0;
-        let ready = 0;
-        const app = await defineServer(createBaseOptions({
-            mode: 'test',
-            backgroundWorkers: async () => {
-                workers += 1;
-            },
-            afterReady: async () => {
-                ready += 1;
-            },
-        }));
-        await app.close();
-        expect(workers).toBe(0);
-        expect(ready).toBe(0);
-    });
-    it('openapi-build 模式下连库/连 Redis 与集合类初始化确实未执行', async () => {
-        const calls = { initGlobalConfig: 0, initClients: 0, initServices: 0, workers: 0, ready: 0, routers: 0 };
-        const app = await defineServer(createBaseOptions({
-            mode: 'openapi-build',
-            initGlobalConfig: () => {
-                calls.initGlobalConfig += 1;
-            },
-            initClients: async () => {
-                calls.initClients += 1;
-            },
-            initServices: async () => {
-                calls.initServices += 1;
-            },
-            backgroundWorkers: async () => {
-                calls.workers += 1;
-            },
-            afterReady: async () => {
-                calls.ready += 1;
-            },
-            registerRouters: () => {
-                calls.routers += 1;
-            },
-        }));
-        await app.close();
-        expect(calls).toEqual({ initGlobalConfig: 0, initClients: 0, initServices: 0, workers: 0, ready: 0, routers: 1 });
-    });
-    it('production 模式下后台 worker / afterReady 都会执行', async () => {
-        let workers = 0;
-        let ready = 0;
-        const app = await defineServer(createBaseOptions({
-            mode: 'production',
-            backgroundWorkers: async () => {
-                workers += 1;
-            },
-            afterReady: async () => {
-                ready += 1;
-            },
-        }));
-        await app.close();
-        expect(workers).toBe(1);
-        expect(ready).toBe(1);
-    });
-    it('database: false 时第 3 步空转，createServices 收到 undefined db', async () => {
-        let received = 'sentinel';
-        const app = await defineServer(createBaseOptions({
-            modules: { ...P1_OPT_OUT, database: false },
-            createServices: (ctx) => {
-                received = ctx.db;
-                return {};
-            },
-        }));
-        await app.close();
-        expect(received).toBeUndefined();
-    });
-});
-describe('defineServer 模块覆盖与 Db 推断', () => {
-    it('Db 泛型从 database 模块推断（决策 10-2，无需强转）', async () => {
-        const database = createPrismaDatabaseModule({
-            PrismaClient: FakeClient,
-            PrismaNamespace: FAKE_PRISMA_NAMESPACE,
-        });
-        const app = await defineServer({
-            serviceName: 'test',
-            title: 'Test',
-            description: 'Test service',
-            errors: DUMMY_ERRORS,
-            config: TEST_CONFIG,
-            modules: { ...P1_OPT_OUT, database },
-            serverOptions: { port: 0, host: '127.0.0.1' },
-            signal: false,
-            createServices: (ctx) => {
-                expectTypeOf(ctx.db).toEqualTypeOf();
-                return {};
-            },
-            registerRouters: () => undefined,
-        });
-        await app.close();
-    });
-    it('整体覆盖 database 模块时使用覆盖实现的 createClient', async () => {
-        let created = 0;
-        const database = {
-            name: 'database',
-            createClient: () => {
-                created += 1;
-                return { tag: 'custom' };
-            },
-            classifyError: () => null,
-        };
-        let received;
-        const app = await defineServer(createBaseOptions({
-            modules: { ...P1_OPT_OUT, database: database },
-            createServices: (ctx) => {
-                received = ctx.db;
-                return {};
-            },
-        }));
-        await app.close();
-        expect(created).toBe(1);
-        expect(received).toEqual({ tag: 'custom' });
-    });
-});

package/output/app/env.d.ts

@@ -1,24 +0,0 @@
-/**
- * 默认 env 文件分层（低 → 高优先级，后者覆盖前者）：
- *
- *   .env.dev   已提交进仓库的 dev 默认值（克隆后 `pnpm run dev` 开箱即用）
- *   .env       本机私有覆盖（已被 gitignore）
- *   .env.local 本机更高优先级覆盖（已被 gitignore）
- *
- * 真实环境变量（进程/容器注入）优先级最高，任何 .env 文件都不会覆盖它们 —— 这条保证让 CI、
- * helm、`docker run -e` 等显式注入始终生效，也避免测试探针
- * （`check-test-database-isolation`）注入的连接串被仓库里的默认值顶掉。
- *
- * 解析器与 account / expense / notice / release 四家现状保持一致，统一使用 `dotenv`，
- * 以保证多行值、引号/转义、`export` 前缀等细节语义完全等价（design §6：与现状逐字一致）。
- */
-export declare const ENV_FILE_LAYERS: readonly [".env.dev", ".env", ".env.local"];
-/**
- * 按分层顺序加载 env 文件（design 决策 #5：独立导出，不塞进 `defineServer`）。
- *
- * 必须在任何 `config` 读取之前调用；测试 / 脚本同样复用本函数。
- *
- * @param extraLayers 追加在最高优先级的额外层，例如测试配置传 `['.env.test.local']`
- */
-export declare function loadEnvFiles(extraLayers?: readonly string[]): void;
-//# sourceMappingURL=env.d.ts.map

package/output/app/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../source/app/env.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,6CAA8C,CAAA;AAU1E;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,WAAW,GAAE,SAAS,MAAM,EAAO,GAAG,IAAI,CAUtE"}

package/output/app/env.js

@@ -1,38 +0,0 @@
-import { config } from 'dotenv';
-/**
- * 默认 env 文件分层（低 → 高优先级，后者覆盖前者）：
- *
- *   .env.dev   已提交进仓库的 dev 默认值（克隆后 `pnpm run dev` 开箱即用）
- *   .env       本机私有覆盖（已被 gitignore）
- *   .env.local 本机更高优先级覆盖（已被 gitignore）
- *
- * 真实环境变量（进程/容器注入）优先级最高，任何 .env 文件都不会覆盖它们 —— 这条保证让 CI、
- * helm、`docker run -e` 等显式注入始终生效，也避免测试探针
- * （`check-test-database-isolation`）注入的连接串被仓库里的默认值顶掉。
- *
- * 解析器与 account / expense / notice / release 四家现状保持一致，统一使用 `dotenv`，
- * 以保证多行值、引号/转义、`export` 前缀等细节语义完全等价（design §6：与现状逐字一致）。
- */
-export const ENV_FILE_LAYERS = ['.env.dev', '.env', '.env.local'];
-/**
- * 首次 import 时的真实环境变量快照（此时还没有任何 .env 文件被加载）。
- * 加载结束后原样恢复，实现「外部注入 > .env.local > .env > .env.dev」。
- */
-const EXTERNAL_ENV = new Map(Object.entries(process.env).filter((entry) => entry[1] !== undefined));
-/**
- * 按分层顺序加载 env 文件（design 决策 #5：独立导出，不塞进 `defineServer`）。
- *
- * 必须在任何 `config` 读取之前调用；测试 / 脚本同样复用本函数。
- *
- * @param extraLayers 追加在最高优先级的额外层，例如测试配置传 `['.env.test.local']`
- */
-export function loadEnvFiles(extraLayers = []) {
-    const layers = [...ENV_FILE_LAYERS, ...extraLayers];
-    layers.forEach((path, index) => {
-        // 第一层不覆盖已有值，后续层逐层覆盖前一层
-        config({ path, override: index > 0 });
-    });
-    for (const [key, value] of EXTERNAL_ENV) {
-        process.env[key] = value;
-    }
-}