@taicode/common-server 4.0.0-beta.2 → 4.0.0-beta.4

package/output/app/env.test.js

@@ -1,124 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-/**
- * env 加载契约（设计 §3.1 ①）。
- *
- * 固定约定：`.env.dev` < `.env` < `.env.local`（外部注入最高），`ENV=test` 追加 `.env.test.local`；
- * 固定读取 `ENV` / `API_PORT` / `LOG_LEVEL`，端口**只读 `API_PORT`，绝不回退 `PORT`**。
- */
-const ENV_KEYS = [
-    'LAYER',
-    'OVERRIDE',
-    'ONLY_DEV',
-    'ONLY_ENV',
-    'ONLY_LOCAL',
-    'EXTERNAL_ONLY',
-    'ONLY_TEST',
-    'EXPORTED',
-    'QUOTED',
-    'MULTI',
-    'HASHED',
-    'ENV',
-    'API_PORT',
-    'PORT',
-    'LOG_LEVEL',
-];
-function clearEnvKeys() {
-    for (const key of ENV_KEYS) {
-        delete process.env[key];
-    }
-}
-/** 重新求值 `env.js`（`EXTERNAL_ENV` 快照在模块首次求值时抓取） */
-async function importEnvModule() {
-    vi.resetModules();
-    return import('./env.js');
-}
-describe('env 加载（设计 §3.1 ①）', () => {
-    let previousCwd;
-    let directory;
-    beforeEach(() => {
-        previousCwd = process.cwd();
-        directory = mkdtempSync(join(tmpdir(), 'common-app-env-'));
-        writeFileSync(join(directory, '.env.dev'), 'LAYER=dev\nONLY_DEV=dev\nOVERRIDE=dev\n');
-        writeFileSync(join(directory, '.env'), 'LAYER=env\nONLY_ENV=env\nOVERRIDE=env\n');
-        writeFileSync(join(directory, '.env.local'), 'LAYER=local\nONLY_LOCAL=local\nOVERRIDE=local\n');
-        process.chdir(directory);
-        clearEnvKeys();
-    });
-    afterEach(() => {
-        process.chdir(previousCwd);
-        rmSync(directory, { recursive: true, force: true });
-        clearEnvKeys();
-        vi.resetModules();
-    });
-    it('分层优先级：外部注入 > .env.local > .env > .env.dev', async () => {
-        process.env.LAYER = 'external';
-        process.env.EXTERNAL_ONLY = 'external';
-        const { loadEnvFiles } = await importEnvModule();
-        loadEnvFiles();
-        expect(process.env.LAYER).toBe('external');
-        expect(process.env.EXTERNAL_ONLY).toBe('external');
-        expect(process.env.OVERRIDE).toBe('local');
-        expect(process.env.ONLY_DEV).toBe('dev');
-        expect(process.env.ONLY_ENV).toBe('env');
-        expect(process.env.ONLY_LOCAL).toBe('local');
-    });
-    it('追加层（如 .env.test.local）优先级最高', async () => {
-        writeFileSync(join(directory, '.env.test.local'), 'OVERRIDE=test-local\nONLY_TEST=1\n');
-        const { loadEnvFiles } = await importEnvModule();
-        loadEnvFiles(['.env.test.local']);
-        expect(process.env.OVERRIDE).toBe('test-local');
-        expect(process.env.ONLY_TEST).toBe('1');
-    });
-    it('缺失的 env 文件不报错，已有层照常生效', async () => {
-        rmSync(join(directory, '.env.local'));
-        const { loadEnvFiles } = await importEnvModule();
-        expect(() => loadEnvFiles()).not.toThrow();
-        expect(process.env.ONLY_DEV).toBe('dev');
-        expect(process.env.OVERRIDE).toBe('env');
-    });
-    it('dotenv 语义：export 前缀 / 引号 / 转义 / 多行 / 行尾注释（与四家现状逐字一致）', async () => {
-        writeFileSync(join(directory, '.env.local'), ['export EXPORTED=1', 'QUOTED="a b"', 'MULTI="line1\\nline2"', 'HASHED=value # 行尾注释'].join('\n'));
-        const { loadEnvFiles } = await importEnvModule();
-        loadEnvFiles();
-        expect(process.env.EXPORTED).toBe('1');
-        expect(process.env.QUOTED).toBe('a b');
-        expect(process.env.MULTI).toBe('line1\nline2');
-        expect(process.env.HASHED).toBe('value');
-    });
-    it('loadRuntimeEnvFiles：ENV=test 时追加 .env.test.local', async () => {
-        writeFileSync(join(directory, '.env.dev'), 'LAYER=dev\nOVERRIDE=dev\nENV=test\nAPI_PORT=4321\n');
-        writeFileSync(join(directory, '.env.test.local'), 'LOG_LEVEL=debug\nONLY_TEST=1\n');
-        const { loadRuntimeEnvFiles } = await importEnvModule();
-        const env = loadRuntimeEnvFiles();
-        expect(env.ENV).toBe('test');
-        expect(env.API_PORT).toBe('4321');
-        expect(env.LOG_LEVEL).toBe('debug');
-        expect(process.env.ONLY_TEST).toBe('1');
-    });
-    it('loadRuntimeEnvFiles：ENV 非 test 时不加载 .env.test.local', async () => {
-        writeFileSync(join(directory, '.env.local'), 'ENV=development\n');
-        writeFileSync(join(directory, '.env.test.local'), 'LOG_LEVEL=debug\nONLY_TEST=1\n');
-        const { loadRuntimeEnvFiles } = await importEnvModule();
-        const env = loadRuntimeEnvFiles();
-        expect(env.ENV).toBe('development');
-        expect(env.LOG_LEVEL).toBe('info');
-        expect(process.env.ONLY_TEST).toBeUndefined();
-    });
-    it('固定读取：只认 API_PORT（绝不回退 PORT），LOG_LEVEL 默认 info，ENV 缺省空串', async () => {
-        process.env.PORT = '9999';
-        const { resolveConfigEnv } = await importEnvModule();
-        const env = resolveConfigEnv();
-        expect(env.API_PORT).toBe('');
-        expect(env.LOG_LEVEL).toBe('info');
-        expect(env.ENV).toBe('');
-    });
-    it('固有常量：分层顺序 / 测试层 / 默认日志级别', async () => {
-        const { ENV_FILE_LAYERS, TEST_ENV_FILE_LAYER, DEFAULT_LOG_LEVEL } = await importEnvModule();
-        expect(ENV_FILE_LAYERS).toEqual(['.env.dev', '.env', '.env.local']);
-        expect(TEST_ENV_FILE_LAYER).toBe('.env.test.local');
-        expect(DEFAULT_LOG_LEVEL).toBe('info');
-    });
-});

package/output/app/error-contract.test.d.ts

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

package/output/app/error-contract.test.d.ts.map

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

package/output/app/error-contract.test.js

@@ -1,227 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { defineServer, startServer } from './entries.js';
-import { SystemError, UserError } from './errors.js';
-/**
- * 错误契约——**强制、不可配置**。
- *
- * 响应信封 `{ status, message, data }`（错误时 `data: null`，`status` 放错误码字符串）；
- * 映射固定：`UserError`→400（`error.status` 字面量）/ `SystemError`→500 / zod→400 / 未知→500 /
- * 未匹配路由→404。错误只给稳定**码**，文案不归框架。
- */
-/** zod validator 由 core 的 `schema` 统一装配，运行时按 zod 校验（类型上仍是 FastifySchema） */
-const validatedQuerySchema = {
-    querystring: z.object({ count: z.coerce.number().int().min(1) }),
-};
-function createErrorContractServer() {
-    return defineServer({
-        app: { service: 'error-contract', title: 'Error Contract', version: '1.0.0' },
-        resources: () => ({}),
-        config: () => ({}),
-        services: () => ({}),
-        middlewares: () => [],
-        routers: (ctx) => {
-            ctx.app.get('/ok', () => ({ hello: 'world' }));
-            ctx.app.get('/envelope', () => ({ status: 'CUSTOM', message: 'm', data: 1 }));
-            ctx.app.get('/user-error', () => {
-                throw new UserError('INVALID_TOKEN', undefined, 'token 无效');
-            });
-            ctx.app.get('/system-error', () => {
-                throw new SystemError('DATABASE_UNAVAILABLE', undefined, '数据库不可用');
-            });
-            ctx.app.get('/unknown-error', () => {
-                throw new Error('boom');
-            });
-            ctx.app.get('/validated', { schema: validatedQuerySchema }, (request) => ({
-                count: request.query.count,
-            }));
-        },
-    });
-}
-describe('错误契约', () => {
-    it('成功信封：{ status: SUCCESS, message: ok, data }', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/ok' });
-        expect(response.statusCode).toBe(200);
-        expect(response.json()).toEqual({ status: 'SUCCESS', message: 'ok', data: { hello: 'world' } });
-        await app.close();
-    });
-    it('已是信封的载荷不被二次包裹', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/envelope' });
-        expect(response.statusCode).toBe(200);
-        expect(response.json()).toEqual({ status: 'CUSTOM', message: 'm', data: 1 });
-        await app.close();
-    });
-    it('UserError → 400（取 `error.status` 字面量），status 放错误码、data 为 null', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/user-error' });
-        expect(response.statusCode).toBe(400);
-        expect(response.json()).toEqual({ status: 'INVALID_TOKEN', message: 'token 无效', data: null });
-        await app.close();
-    });
-    it('SystemError → 500（取 `error.status` 字面量）', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/system-error' });
-        expect(response.statusCode).toBe(500);
-        expect(response.json()).toEqual({ status: 'DATABASE_UNAVAILABLE', message: '数据库不可用', data: null });
-        await app.close();
-    });
-    it('未知错误 → 500 + UNKNOWN_ERROR', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/unknown-error' });
-        expect(response.statusCode).toBe(500);
-        expect(response.json()).toEqual({ status: 'UNKNOWN_ERROR', message: 'boom', data: null });
-        await app.close();
-    });
-    it('zod 校验失败 → 400（INVALID_INPUT）；通过校验 → 200', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const invalid = await app.inject({ method: 'GET', url: '/validated?count=0' });
-        expect(invalid.statusCode).toBe(400);
-        const invalidBody = invalid.json();
-        expect(invalidBody.status).toBe('INVALID_INPUT');
-        expect(invalidBody.data).toBeNull();
-        expect(invalidBody.message).toContain('count');
-        const valid = await app.inject({ method: 'GET', url: '/validated?count=3' });
-        expect(valid.statusCode).toBe(200);
-        expect(valid.json()).toEqual({ status: 'SUCCESS', message: 'ok', data: { count: 3 } });
-        await app.close();
-    });
-    it('未匹配路由 → 404 + NOT_IMPLEMENTED', async () => {
-        const app = await startServer(createErrorContractServer(), { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/missing' });
-        expect(response.statusCode).toBe(404);
-        const body = response.json();
-        expect(body.status).toBe('NOT_IMPLEMENTED');
-        expect(body.data).toBeNull();
-        expect(body.message).toContain('GET /missing');
-        await app.close();
-    });
-    it('资源注册的 `ctx.registerClassifyError` 分类器生效（→500，错误码 = 分类器返回的 SystemError.type）', async () => {
-        const server = defineServer({
-            app: { service: 'error-contract-database', title: 'Error Contract Database', version: '1.0.0' },
-            resources: (ctx) => {
-                ctx.registerClassifyError((error) => error instanceof Error && error.message === 'pg down'
-                    ? new SystemError('DATABASE_ERROR', { operation: 'query' }, 'pg down')
-                    : null);
-                return {};
-            },
-            config: () => ({}),
-            services: () => ({}),
-            middlewares: () => [],
-            routers: (ctx) => {
-                ctx.app.get('/database-down', () => {
-                    throw new Error('pg down');
-                });
-            },
-        });
-        const app = await startServer(server, { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/database-down' });
-        expect(response.statusCode).toBe(500);
-        expect(response.json()).toEqual({ status: 'DATABASE_ERROR', message: 'pg down', data: null });
-        await app.close();
-    });
-    it('跨资源注册：每个资源各注册自己的分类器，各自认领域内错误（顺序短路），都不认领则兜底', async () => {
-        const calls = [];
-        const server = defineServer({
-            app: { service: 'error-contract-cross-resource', title: 'Error Contract Cross Resource', version: '1.0.0' },
-            resources: (ctx) => {
-                // prisma 资源：只认领自己域内的 Prisma 错误（认领不了返回 null）
-                ctx.registerClassifyError((error) => {
-                    calls.push('prisma');
-                    return error instanceof Error && error.name === 'PrismaError'
-                        ? new SystemError('DATABASE_ERROR', { operation: 'query' }, '数据库错误')
-                        : null;
-                });
-                // cache 资源：只认领自己域内的缓存错误
-                ctx.registerClassifyError((error) => {
-                    calls.push('cache');
-                    return error instanceof Error && error.name === 'CacheError'
-                        ? new SystemError('CACHE_ERROR', undefined, '缓存错误')
-                        : null;
-                });
-                return { prisma: {}, cache: {} };
-            },
-            config: () => ({}),
-            services: () => ({}),
-            middlewares: () => [],
-            routers: (ctx) => {
-                ctx.app.get('/prisma-error', () => {
-                    throw Object.assign(new Error('db down'), { name: 'PrismaError' });
-                });
-                ctx.app.get('/cache-error', () => {
-                    throw Object.assign(new Error('cache down'), { name: 'CacheError' });
-                });
-                ctx.app.get('/unclaimed-error', () => {
-                    throw new Error('someone else error');
-                });
-            },
-        });
-        const app = await startServer(server, { listen: false });
-        // ① prisma 域：prisma 分类器认领，错误码正确；首个命中即短路（不再问 cache）
-        calls.length = 0;
-        const prisma = await app.inject({ method: 'GET', url: '/prisma-error' });
-        expect(prisma.statusCode).toBe(500);
-        expect(prisma.json()).toEqual({ status: 'DATABASE_ERROR', message: '数据库错误', data: null });
-        expect(calls).toEqual(['prisma']);
-        // ② cache 域：prisma 返回 null → 交给 cache 认领，错误码正确
-        calls.length = 0;
-        const cache = await app.inject({ method: 'GET', url: '/cache-error' });
-        expect(cache.statusCode).toBe(500);
-        expect(cache.json()).toEqual({ status: 'CACHE_ERROR', message: '缓存错误', data: null });
-        expect(calls).toEqual(['prisma', 'cache']);
-        // ③ 都不认领 → 落 `UNKNOWN_ERROR` 兜底
-        calls.length = 0;
-        const unclaimed = await app.inject({ method: 'GET', url: '/unclaimed-error' });
-        expect(unclaimed.statusCode).toBe(500);
-        expect(unclaimed.json()).toEqual({ status: 'UNKNOWN_ERROR', message: 'someone else error', data: null });
-        expect(calls).toEqual(['prisma', 'cache']);
-        await app.close();
-    });
-    it('一个资源都不注册分类器 → 资源错误分支不生效，落 `UNKNOWN_ERROR` 兜底', async () => {
-        const server = defineServer({
-            app: { service: 'error-contract-none', title: 'Error Contract None', version: '1.0.0' },
-            resources: () => ({}),
-            config: () => ({}),
-            services: () => ({}),
-            middlewares: () => [],
-            routers: (ctx) => {
-                ctx.app.get('/boom', () => {
-                    throw new Error('boom');
-                });
-            },
-        });
-        const app = await startServer(server, { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/boom' });
-        expect(response.statusCode).toBe(500);
-        expect(response.json()).toEqual({ status: 'UNKNOWN_ERROR', message: 'boom', data: null });
-        await app.close();
-    });
-    it('注册的分类器不影响既有分支：`UserError` 仍走 400（分类器只在资源错误分支求值）', async () => {
-        let classified = 0;
-        const server = defineServer({
-            app: { service: 'error-contract-user', title: 'Error Contract User', version: '1.0.0' },
-            resources: (ctx) => {
-                ctx.registerClassifyError((error) => {
-                    classified += 1;
-                    return error instanceof Error ? new SystemError('SHOULD_NOT_HAPPEN', undefined, 'x') : null;
-                });
-                return {};
-            },
-            config: () => ({}),
-            services: () => ({}),
-            middlewares: () => [],
-            routers: (ctx) => {
-                ctx.app.get('/user-error-2', () => {
-                    throw new UserError('INVALID_TOKEN', undefined, 'token 无效');
-                });
-            },
-        });
-        const app = await startServer(server, { listen: false });
-        const response = await app.inject({ method: 'GET', url: '/user-error-2' });
-        expect(response.statusCode).toBe(400);
-        expect(response.json()).toEqual({ status: 'INVALID_TOKEN', message: 'token 无效', data: null });
-        expect(classified).toBe(0); // `UserError` 在分支①命中，分类器根本没被求值
-        await app.close();
-    });
-});

package/output/app/errors.d.ts

@@ -1,20 +0,0 @@
-import type { ErrorContext } from '@taicode/common-base';
-export declare class UserError extends Error {
-    readonly type: string;
-    readonly context?: ErrorContext | undefined;
-    /** 类型守卫（`Symbol.for` 品牌，不用 `instanceof`） */
-    static is(value: unknown): value is UserError;
-    /** 固定 HTTP 状态（字面量类型） */
-    readonly status: 400;
-    constructor(type: string, context?: ErrorContext | undefined, message?: string);
-}
-export declare class SystemError extends Error {
-    readonly type: string;
-    readonly context?: ErrorContext | undefined;
-    /** 类型守卫（`Symbol.for` 品牌，不用 `instanceof`） */
-    static is(value: unknown): value is SystemError;
-    /** 固定 HTTP 状态（字面量类型） */
-    readonly status: 500;
-    constructor(type: string, context?: ErrorContext | undefined, message?: string);
-}
-//# sourceMappingURL=errors.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../source/app/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAsBxD,qBAAa,SAAU,SAAQ,KAAK;aASC,IAAI,EAAE,MAAM;aAAkB,OAAO,CAAC,EAAE,YAAY;IARvF,4CAA4C;IAC5C,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS;IAI7C,wBAAwB;IACxB,QAAQ,CAAC,MAAM,EAAG,GAAG,CAAS;gBAEK,IAAI,EAAE,MAAM,EAAkB,OAAO,CAAC,EAAE,YAAY,YAAA,EAAE,OAAO,SAAK;CAKtG;AAED,qBAAa,WAAY,SAAQ,KAAK;aASD,IAAI,EAAE,MAAM;aAAkB,OAAO,CAAC,EAAE,YAAY;IARvF,4CAA4C;IAC5C,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW;IAI/C,wBAAwB;IACxB,QAAQ,CAAC,MAAM,EAAG,GAAG,CAAS;gBAEK,IAAI,EAAE,MAAM,EAAkB,OAAO,CAAC,EAAE,YAAY,YAAA,EAAE,OAAO,SAAK;CAKtG"}

package/output/app/errors.js

@@ -1,51 +0,0 @@
-/**
- * 错误契约（N2 §2.12）。
- *
- * 框架直接提供并导出 `UserError` / `SystemError`：
- * - `status` 是**字面量**（`400` / `500`）—— 映射表写成
- *   `Record<UserError['status'] | SystemError['status'], number>` 时若改错直接编译失败；
- * - `is()` 是**类型守卫**，走 `Symbol.for` 品牌（**不用 `instanceof`**：跨包 / 编译后 / 原型链丢失
- *   都仍然可靠）；品牌与 `@taicode/common-base` 同名，故基座抛出的同类错误同样被识别；
- * - 业务只抛这两个错误，状态码映射由框架固定（`UserError`→400 / `SystemError`→500）。
- *
- * 构造签名保持 `(code, context?, message?)`。
- */
-const USER_ERROR_BRAND = Symbol.for('@taicode/common/UserError');
-const SYSTEM_ERROR_BRAND = Symbol.for('@taicode/common/SystemError');
-function hasBrand(value, brand) {
-    return typeof value === 'object' && value !== null && value[brand] === true;
-}
-export class UserError extends Error {
-    type;
-    context;
-    /** 类型守卫（`Symbol.for` 品牌，不用 `instanceof`） */
-    static is(value) {
-        return hasBrand(value, USER_ERROR_BRAND);
-    }
-    /** 固定 HTTP 状态（字面量类型） */
-    status = 400;
-    constructor(type, context, message = '') {
-        super(message, context);
-        this.type = type;
-        this.context = context;
-        this.name = 'UserError';
-        Object.defineProperty(this, USER_ERROR_BRAND, { value: true });
-    }
-}
-export class SystemError extends Error {
-    type;
-    context;
-    /** 类型守卫（`Symbol.for` 品牌，不用 `instanceof`） */
-    static is(value) {
-        return hasBrand(value, SYSTEM_ERROR_BRAND);
-    }
-    /** 固定 HTTP 状态（字面量类型） */
-    status = 500;
-    constructor(type, context, message = '') {
-        super(message, context);
-        this.type = type;
-        this.context = context;
-        this.name = 'SystemError';
-        Object.defineProperty(this, SYSTEM_ERROR_BRAND, { value: true });
-    }
-}

package/output/app/generate-openapi.test.d.ts

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

package/output/app/generate-openapi.test.d.ts.map

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

package/output/app/generate-openapi.test.js

@@ -1,123 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { defineServer, generateOpenApi, startServer } from './entries.js';
-import { createRedis } from './redis.js';
-/**
- * `generateOpenApi()` 红线。
- *
- * 全程**不得要求配置有效**：不跑 `config` 槽位、不要求 `DATABASE_URL` / `REDIS_URL` 有效、不建连；
- * `resources`（只构造不建连）/ `services` / 中间件注册 / 路由注册照常执行。
- * 跳过集：`config` / `initLifecycleUnits` / `listen`。
- */
-const routeSchema = {
-    querystring: z.object({ name: z.string().optional() }),
-};
-describe('generateOpenApi 红线', () => {
-    it('不跑 config、不要求 DATABASE_URL / REDIS_URL，能出 spec', async () => {
-        delete process.env.DATABASE_URL;
-        delete process.env.REDIS_URL;
-        let configCalls = 0;
-        const server = defineServer({
-            app: { service: 'openapi-test', title: 'OpenAPI Test', version: '1.2.3' },
-            resources: () => ({ database: { connected: false } }),
-            config: () => {
-                configCalls += 1;
-                return {};
-            },
-            services: () => ({}),
-            middlewares: () => [],
-            routers: (ctx) => {
-                ctx.app.get('/widgets', { schema: routeSchema }, () => []);
-            },
-        });
-        const spec = (await generateOpenApi(server));
-        expect(configCalls).toBe(0);
-        expect(spec.openapi).toBe('3.0.3');
-        expect(spec.info).toMatchObject({ title: 'OpenAPI Test', version: '1.2.3' });
-        // 身份块只有 service / title / version：`info.description` 不再由框架填
-        expect(spec.info?.description).toBeUndefined();
-        expect(spec.servers).toEqual([{ url: '/' }]);
-        expect(Object.keys(spec.paths ?? {})).toContain('/widgets');
-        expect(Object.keys(spec.components?.securitySchemes ?? {})).toContain('bearerAuth');
-    });
-    it('跳过集：不跑 config / initLifecycleUnits（但跑 resources / services / 中间件注册 / routers）', async () => {
-        const calls = [];
-        const server = defineServer({
-            app: { service: 'openapi-skip-set', title: 'OpenAPI Skip Set', version: '1.0.0' },
-            resources: () => {
-                calls.push('resources');
-                return {};
-            },
-            config: () => {
-                calls.push('config');
-                return {};
-            },
-            services: () => {
-                calls.push('services');
-                return {
-                    a: {
-                        init: () => {
-                            calls.push('init:a');
-                        },
-                    },
-                };
-            },
-            middlewares: () => [
-                {
-                    name: 'probe',
-                    register: () => {
-                        calls.push('register:probe');
-                    },
-                },
-            ],
-            routers: () => {
-                calls.push('routers');
-            },
-        });
-        await generateOpenApi(server);
-        expect(calls).toEqual(['resources', 'services', 'register:probe', 'routers']);
-    });
-    it('REDIS_URL 存在时仍不建连（惰性包装）', async () => {
-        process.env.REDIS_URL = 'redis://127.0.0.1:1/0';
-        try {
-            const server = defineServer({
-                app: { service: 'openapi-redis-lazy', title: 'Redis Lazy', version: '1.0.0' },
-                // resources 里照常构造 Redis 句柄（惰性包装：不建连、不 ping）
-                resources: (ctx) => ({ redis: createRedis(ctx.env, ctx.log) }),
-                config: () => ({}),
-                services: () => ({}),
-                middlewares: () => [],
-                routers: () => undefined,
-            });
-            const spec = (await generateOpenApi(server));
-            expect(spec.openapi).toBe('3.0.3');
-        }
-        finally {
-            delete process.env.REDIS_URL;
-        }
-    });
-});
-describe('startServer 与 generateOpenApi 共用同一份定义', () => {
-    it('startServer(server, { listen: false }) 返回原生实例、可 inject，且会跑 config', async () => {
-        let configCalls = 0;
-        const server = defineServer({
-            app: { service: 'openapi-shared-definition', title: 'Shared Definition', version: '1.0.0' },
-            resources: () => ({}),
-            config: () => {
-                configCalls += 1;
-                return {};
-            },
-            services: () => ({}),
-            middlewares: () => [],
-            routers: (ctx) => {
-                ctx.app.get('/ping', () => ({ pong: true }));
-            },
-        });
-        const app = await startServer(server, { listen: false });
-        expect(typeof app.inject).toBe('function');
-        const response = await app.inject({ method: 'GET', url: '/ping' });
-        expect(response.statusCode).toBe(200);
-        expect(configCalls).toBe(1);
-        await app.close();
-    });
-});

package/output/app/lifecycle-logging.test.d.ts

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

package/output/app/lifecycle-logging.test.d.ts.map

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