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

package/output/app/lifecycle-logging.test.js

@@ -1,155 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { defineServer, startServer } from './entries.js';
-import { buildDisposeOrder, initServiceUnits, LIFECYCLE_PHASE_DISPOSE, LIFECYCLE_PHASE_INIT, MIDDLEWARES_LOG_STAGE, middlewareUnitName, SERVICES_STAGE, serviceUnitName, } from './lifecycle.js';
-import { createRecordingLogger } from './test-support.js';
-/**
- * 逐单元日志。
- *
- * - **注册期**：每个中间件注册后打一条 `debug`，带 `{ service, unit, stage: 'middlewares' }`；
- * - **init / dispose**：逐单元 `debug`（开始 / 完成），失败 `error`；带 `{ service, unit, stage, phase }`；
- * - 中间件名字：`unit.name ?? '<service>:middleware[<index>]'`；services 用对象键。
- *
- * 分两层验证：
- * 1. **单元层**：直接调 `initServiceUnits` / `buildDisposeOrder`，注入记录型 logger；
- * 2. **真路径**：`startServer(server, { listen: false })` 走完整装配；把框架 logger 的写入流接到
- *    捕获数组（mock `./core/logging.js` 的 `createLoggerOptions`），再按字段断言。
- */
-// ── 单元层：记录型 logger ────────────────────────────────────────
-/** 按相位 / 阶段 / 消息片段挑出 `unit` 列表（保序） */
-function unitsOf(log, phase, stage, messagePart) {
-    return log.entries
-        .filter((entry) => entry.level === 'debug' && entry.msg?.includes(messagePart) === true)
-        .map((entry) => entry.obj)
-        .filter((fields) => fields.phase === phase && fields.stage === stage)
-        .map((fields) => fields.unit);
-}
-function expectServiceField(log, service) {
-    const fields = log.entries
-        .filter((entry) => entry.level === 'debug')
-        .map((entry) => entry.obj);
-    expect(fields.length).toBeGreaterThan(0);
-    for (const field of fields) {
-        expect(field.service).toBe(service);
-    }
-}
-describe('逐单元日志：init / dispose', () => {
-    it('init 逐单元 debug：单元名 = 对象键', async () => {
-        const log = createRecordingLogger();
-        const services = {
-            alpha: { init: () => undefined },
-            beta: { init: () => undefined },
-        };
-        await initServiceUnits({ service: 'svc', log, services });
-        expect(unitsOf(log, LIFECYCLE_PHASE_INIT, SERVICES_STAGE, 'start')).toEqual(['alpha', 'beta']);
-        expect(unitsOf(log, LIFECYCLE_PHASE_INIT, SERVICES_STAGE, 'done')).toEqual(['alpha', 'beta']);
-        expectServiceField(log, 'svc');
-        expect(serviceUnitName('alpha')).toBe('alpha');
-    });
-    it('dispose 逐单元 debug：声明序逆序', async () => {
-        const log = createRecordingLogger();
-        const services = {
-            alpha: { dispose: () => undefined },
-            beta: { dispose: () => undefined },
-        };
-        for (const step of buildDisposeOrder({ service: 'svc', log, services })) {
-            await step();
-        }
-        expect(unitsOf(log, LIFECYCLE_PHASE_DISPOSE, SERVICES_STAGE, 'start')).toEqual(['beta', 'alpha']);
-        expectServiceField(log, 'svc');
-    });
-    it('单元 init 抛错 → 逐单元 error（带 unit / stage / phase）后重新抛出', async () => {
-        const log = createRecordingLogger();
-        const services = {
-            boom: {
-                init: () => {
-                    throw new Error('init boom');
-                },
-            },
-        };
-        await expect(initServiceUnits({ service: 'svc', log, services })).rejects.toThrow('init boom');
-        const failure = log.entries.find((entry) => entry.level === 'error');
-        expect(failure).toBeDefined();
-        const fields = failure?.obj;
-        expect(fields.unit).toBe('boom');
-        expect(fields.stage).toBe(SERVICES_STAGE);
-        expect(fields.phase).toBe(LIFECYCLE_PHASE_INIT);
-        expect(fields.error.message).toBe('init boom');
-    });
-    it('不传 logger → 生命周期函数照常工作（纯函数式调用不发日志）', async () => {
-        const calls = [];
-        const services = {
-            alpha: {
-                init: () => {
-                    calls.push('init');
-                },
-            },
-        };
-        await initServiceUnits({ services });
-        expect(calls).toEqual(['init']);
-    });
-    it('中间件日志名字退路：`<service>:middleware[index]`', () => {
-        expect(middlewareUnitName('svc', {}, 3)).toBe('svc:middleware[3]');
-        expect(middlewareUnitName('svc', { name: 'named' }, 1)).toBe('named');
-    });
-});
-// ── 真路径：`startServer` 走完整装配，捕获框架 logger 写入 ────────
-const captured = vi.hoisted(() => ({ lines: [] }));
-vi.mock('./core/logging.js', () => ({
-    LOG_REDACT_PATHS: [],
-    // 把 pino 的目标流换成捕获数组（level=debug，否则逐单元 debug 不会落盘）
-    createLoggerOptions: () => ({
-        level: 'debug',
-        stream: {
-            write: (chunk) => {
-                captured.lines.push(chunk);
-            },
-        },
-    }),
-}));
-function capturedRecords() {
-    return captured.lines
-        .join('')
-        .split('\n')
-        .filter((line) => line.trim().length > 0)
-        .map((line) => JSON.parse(line));
-}
-/** 按字段匹配捕获到的记录（pino 还会加 `time` / `pid` 等，故只比关键字段） */
-function matchRecords(records, match) {
-    return records.filter((record) => Object.entries(match).every(([key, value]) => record[key] === value));
-}
-describe('startServer 真路径：注册 / init / dispose 逐单元日志', () => {
-    it('中间件注册、services 的 init / dispose 日志都能拿到名字；未命名用退路', async () => {
-        captured.lines.length = 0;
-        const server = defineServer({
-            app: { service: 'logging-svc', title: 'Logging Service', version: '1.0.0' },
-            resources: () => ({}),
-            config: () => ({}),
-            services: () => ({
-                alpha: {
-                    init: () => undefined,
-                    dispose: () => undefined,
-                },
-            }),
-            middlewares: () => [
-                { name: 'named', register: () => undefined },
-                // 未命名 → 退路 `logging-svc:middleware[1]`
-                { register: () => undefined },
-            ],
-            routers: () => undefined,
-        });
-        const app = await startServer(server, { listen: false });
-        await app.close();
-        const records = capturedRecords();
-        // 注册期：字段 `{ service, unit, stage }`，未命名走退路
-        const registered = matchRecords(records, { msg: '[middleware] registered' });
-        expect(matchRecords(registered, { unit: 'named', stage: MIDDLEWARES_LOG_STAGE }).length).toBe(1);
-        expect(matchRecords(registered, { unit: 'logging-svc:middleware[1]', stage: MIDDLEWARES_LOG_STAGE }).length).toBe(1);
-        expect(matchRecords(registered, { service: 'logging-svc' }).length).toBe(2);
-        // init / dispose：services 逐单元 debug（带 `phase`）
-        expect(matchRecords(records, { unit: 'alpha', stage: SERVICES_STAGE, phase: LIFECYCLE_PHASE_INIT }).length).toBeGreaterThan(0);
-        expect(matchRecords(records, { unit: 'alpha', stage: SERVICES_STAGE, phase: LIFECYCLE_PHASE_DISPOSE }).length).toBeGreaterThan(0);
-        // 中间件**不参与生命周期**：没有 middlewares 阶段的 init / dispose 日志
-        expect(matchRecords(records, { stage: MIDDLEWARES_LOG_STAGE, phase: LIFECYCLE_PHASE_INIT })).toHaveLength(0);
-        expect(matchRecords(records, { stage: MIDDLEWARES_LOG_STAGE, phase: LIFECYCLE_PHASE_DISPOSE })).toHaveLength(0);
-    });
-});

package/output/app/lifecycle.d.ts

@@ -1,70 +0,0 @@
-import type { LoggerLike } from './types.js';
-/**
- * 生命周期序（N1 §4 / N2 §2.5）。
- *
- * **只有 `services` 参与生命周期**：
- * - 单元之间**不得相互依赖**（`services` 的 ctx 没有 `services` 字段，编译期禁止）；
- * - 顺序语义只有一条：按**对象声明序** `init`、**逆序** `dispose`；
- * - `middlewares` 按数组序注册，**不参与生命周期**（要常驻资源就放 `services`）；
- * - `resources` 只是惰性包装（构造不建连），框架不替它们做生命周期。
- */
-export declare const SERVICES_STAGE = "services";
-/** `middlewares` 的**注册期日志**阶段标签（中间件不参与生命周期，只用于注册日志） */
-export declare const MIDDLEWARES_LOG_STAGE = "middlewares";
-/** 生命周期相位（逐单元日志字段 `phase`） */
-export declare const LIFECYCLE_PHASE_INIT = "init";
-export declare const LIFECYCLE_PHASE_DISPOSE = "dispose";
-export type LifecyclePhase = typeof LIFECYCLE_PHASE_INIT | typeof LIFECYCLE_PHASE_DISPOSE;
-/**
- * 逐单元生命周期日志上下文。
- *
- * `log` / `service` 缺省时**不打日志**（纯单测可直接调用生命周期函数，不注入假 logger）。
- * 字段名固定为全拼：`service` + `unit` + `stage` + `phase`。
- */
-export interface LifecycleLogContext {
-    /** 日志标签（`defineServer({ app: { service } })`）；缺省时退路名字失去前缀 */
-    service?: string;
-    /** 记录型 logger（`ctx.log`）；缺省 = 不打日志 */
-    log?: LoggerLike;
-}
-/** 逐单元日志字段（全拼）：`unit` = 有效名字，`stage` = `services` */
-export interface LifecycleUnitLogFields {
-    service: string;
-    unit: string;
-    stage: string;
-    phase: LifecyclePhase;
-}
-/**
- * `services` 有效名字：**对象键即单元名**（N1 §4：没有 `name` 字段）。
- */
-export declare function serviceUnitName(key: string): string;
-/**
- * `middlewares` 日志名字：`unit.name ?? '<service>:middleware[<index>]'`（仅用于注册期日志）。
- */
-export declare function middlewareUnitName(service: string, unit: unknown, index: number): string;
-/** `initServiceUnits` 入参（参数签名内联对象类型已按 lint 规则外提） */
-export interface InitServiceUnitsParams extends LifecycleLogContext {
-    /** `services(ctx)` 返回的对象（**对象键即单元名**） */
-    services?: Record<string, unknown>;
-}
-/**
- * 启动序：`services` 按**对象声明序**逐项 `await init?.()`；逐项打日志。
- */
-export declare function initServiceUnits(params: InitServiceUnitsParams): Promise<void>;
-/** `buildDisposeOrder` / `disposeServiceUnits` 入参（参数签名内联对象类型已按 lint 规则外提） */
-export interface DisposeServiceUnitsParams extends LifecycleLogContext {
-    /** `services(ctx)` 返回的对象（**对象键即单元名**） */
-    services?: Record<string, unknown>;
-}
-/**
- * 关闭序：`services` 按声明序**逆序**逐项 `dispose?.()`。
- */
-export declare function buildDisposeOrder(params: DisposeServiceUnitsParams): Array<() => void | Promise<void>>;
-/**
- * 关闭步 `disposeServices`：`services` 声明序逆序释放。
- *
- * 单元级失败已在 `runLifecycleUnit` 内 `log.error`（带 service / unit / stage / phase）；
- * 此处仅保证单步不阻断后续。
- */
-export declare function disposeServices(params: DisposeServiceUnitsParams): Promise<void>;
-//# sourceMappingURL=lifecycle.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../source/app/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;GAQG;AAEH,eAAO,MAAM,cAAc,aAAa,CAAA;AACxC,uDAAuD;AACvD,eAAO,MAAM,qBAAqB,gBAAgB,CAAA;AAElD,8BAA8B;AAC9B,eAAO,MAAM,oBAAoB,SAAS,CAAA;AAC1C,eAAO,MAAM,uBAAuB,YAAY,CAAA;AAChD,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,GAAG,OAAO,uBAAuB,CAAA;AAEzF;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,sCAAsC;IACtC,GAAG,CAAC,EAAE,UAAU,CAAA;CACjB;AAED,qDAAqD;AACrD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,cAAc,CAAA;CACtB;AAMD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKxF;AAED,oDAAoD;AACpD,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IACjE,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAmCD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpF;AAED,6EAA6E;AAC7E,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACpE,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,yBAAyB,GAAG,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAMtG;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtF"}

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

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

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

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

package/output/app/lifecycle.test.js

@@ -1,152 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { defineServer, startServer } from './entries.js';
-import { buildDisposeOrder, initServiceUnits, serviceUnitName } from './lifecycle.js';
-/**
- * 生命周期（N1 §4）。
- *
- * - **只有 `services` 参与**：按**对象声明序** `init` / **逆序** `dispose`；
- * - **没有 `dependsOn`**（`services` 的 ctx 没有 `services` 字段，编译期禁止互依）；
- * - 单元名 = **对象键**；
- * - `middlewares` 按数组序注册，**不参与生命周期**。
- */
-describe('init / dispose 顺序：声明序 / 逆序（N1 §4 / §5）', () => {
-    it('init：services 按对象声明序', async () => {
-        const calls = [];
-        const services = {
-            ledger: {
-                init: () => {
-                    calls.push('init:ledger');
-                },
-            },
-            repository: {
-                init: () => {
-                    calls.push('init:repository');
-                },
-            },
-            mailer: {
-                init: () => {
-                    calls.push('init:mailer');
-                },
-            },
-        };
-        await initServiceUnits({ services });
-        expect(calls).toEqual(['init:ledger', 'init:repository', 'init:mailer']);
-    });
-    it('dispose：services 按声明序逆序', async () => {
-        const calls = [];
-        const services = {
-            ledger: {
-                dispose: () => {
-                    calls.push('dispose:ledger');
-                },
-            },
-            repository: {
-                dispose: () => {
-                    calls.push('dispose:repository');
-                },
-            },
-        };
-        for (const step of buildDisposeOrder({ services })) {
-            await step();
-        }
-        expect(calls).toEqual(['dispose:repository', 'dispose:ledger']);
-    });
-    it('不是 ServiceUnit 的值照样能放（框架只检测 init / dispose 是否为函数）', async () => {
-        const calls = [];
-        const services = {
-            plain: { hello: 'world' },
-            lifecycle: {
-                init: () => {
-                    calls.push('init:lifecycle');
-                },
-            },
-        };
-        await initServiceUnits({ services });
-        expect(calls).toEqual(['init:lifecycle']);
-    });
-    it('单元名 = 对象键', () => {
-        expect(serviceUnitName('ledger')).toBe('ledger');
-        expect(serviceUnitName('repository')).toBe('repository');
-    });
-});
-describe('startServer 集成：声明序 init / 逆序 dispose', () => {
-    it('services 声明序 init；中间件按数组序注册但不参与生命周期；close 时 services 逆序 dispose', async () => {
-        const calls = [];
-        const server = defineServer({
-            app: { service: 'lifecycle-integration', title: 'Lifecycle Integration', version: '1.0.0' },
-            resources: () => ({}),
-            config: () => ({}),
-            services: () => ({
-                ledger: {
-                    init: () => {
-                        calls.push('init:ledger');
-                    },
-                    dispose: () => {
-                        calls.push('dispose:ledger');
-                    },
-                },
-                repository: {
-                    init: () => {
-                        calls.push('init:repository');
-                    },
-                    dispose: () => {
-                        calls.push('dispose:repository');
-                    },
-                },
-                mailer: {
-                    init: () => {
-                        calls.push('init:mailer');
-                    },
-                    dispose: () => {
-                        calls.push('dispose:mailer');
-                    },
-                },
-            }),
-            middlewares: () => [
-                {
-                    name: 'm1',
-                    register: () => {
-                        calls.push('register:m1');
-                    },
-                },
-                {
-                    name: 'm2',
-                    register: () => {
-                        calls.push('register:m2');
-                    },
-                },
-            ],
-            routers: () => undefined,
-        });
-        const app = await startServer(server, { listen: false });
-        expect(calls).toEqual(['init:ledger', 'init:repository', 'init:mailer', 'register:m1', 'register:m2']);
-        await app.close();
-        expect(calls).toEqual([
-            'init:ledger',
-            'init:repository',
-            'init:mailer',
-            'register:m1',
-            'register:m2',
-            'dispose:mailer',
-            'dispose:repository',
-            'dispose:ledger',
-        ]);
-    });
-    it('单元 init 抛错 → startServer 冒泡失败', async () => {
-        const server = defineServer({
-            app: { service: 'lifecycle-init-error', title: 'Lifecycle Init Error', version: '1.0.0' },
-            resources: () => ({}),
-            config: () => ({}),
-            services: () => ({
-                broken: {
-                    init: () => {
-                        throw new Error('init boom');
-                    },
-                },
-            }),
-            middlewares: () => [],
-            routers: () => undefined,
-        });
-        await expect(startServer(server, { listen: false })).rejects.toThrow('init boom');
-    });
-});

package/output/app/middleware/auth.d.ts

@@ -1,71 +0,0 @@
-import type { MiddlewareContext, MiddlewareUnit } from '../types.js';
-import type { FastifyRequest } from 'fastify';
-/**
- * 标准中间件单元 `auth`（可替换）。
- *
- * 校验下游 token（4/5 服务用）。默认 `skip`：`OPTIONS` → 未匹配路由 → `NoLoginRequired` → `docPath`。
- * 默认 `verify` 为**框架内置 account HTTP 客户端**（`POST /gateway/verify` + 信封解析），可经
- * `verify` 整体替换；account `serviceUrl` 门槛**仅作用于内置 verify**（自定义 `verify` 不受约束）。
- *
- * 另在 `onReady` 阶段默认（`registerPermissions !== false`）向 account **自注册权限操作目录**
- * （`POST /permission/operation/register`）。
- */
-export interface AuthVerifyMetadata {
-    requestId?: string;
-    method?: string;
-    url?: string;
-    ip?: string;
-    ips?: string[];
-    userAgent?: string;
-    referrer?: string;
-}
-export interface AuthVerifyInput {
-    token?: string;
-    apiKey?: string;
-    operation?: string;
-    /** 路由参数（`request.params`），如 `:id` 这类路径参数 */
-    resource?: Record<string, unknown>;
-    accessControls?: string[];
-    /** 请求元信息（仅供下游审计 / 日志；不参与鉴权判定） */
-    metadata?: AuthVerifyMetadata;
-}
-export interface AuthVerifyResult {
-    user?: unknown;
-    token?: unknown;
-}
-/** 跳过条件（返回 true 即放行）；缺省为框架默认 skip 集合 */
-export type AuthSkip<C = unknown, S = unknown> = (request: FastifyRequest, ctx: MiddlewareContext<C, S>) => boolean | undefined;
-export interface AccountIntegrationConfig {
-    enabled?: boolean;
-    serviceUrl?: string;
-    accessKey?: string;
-    secretKey?: string;
-}
-export interface AuthMiddlewareOptions<C = unknown, S = unknown> {
-    /**
-     * 整体替换校验实现（缺省走框架内置 account HTTP 客户端）。
-     *
-     * 提供本项时**不做** account `serviceUrl` 门槛：`serviceUrl` 只服务于内置 verify。
-     */
-    verify?: (input: AuthVerifyInput & {
-        service: string;
-    }, ctx: MiddlewareContext<C, S>) => Promise<AuthVerifyResult>;
-    /** 读取 token 的 cookie 名（缺省现读配置的 `server.cookieNames`） */
-    cookieNames?: string[];
-    /**
-     * 是否在 `startServer` 的 `onReady` 阶段向 account 自注册权限操作（默认 `true`）。
-     *
-     * 跳过条件：本项为 `false`；或配置的 `account` 无 `serviceUrl`（自然排除 account 自身）；
-     * 或出 spec 路径（`generateOpenApi` 不跑 `config` 槽位，配置不可用）。注册失败**不致命**：
-     * `log.error` 后继续启动，不中断 `startServer`。
-     */
-    registerPermissions?: boolean;
-    /** 跳过条件（返回 true 即放行）；缺省为框架默认 skip 集合 */
-    skip?: AuthSkip<C, S>;
-    /** 错误映射（缺省：非 `UserError` / `SystemError` 一律 → `SystemError('EXTERNAL_SERVICE_ERROR')`） */
-    mapError?: (error: unknown) => Error;
-}
-/** 框架默认 skip：OPTIONS → 未匹配路由 → NoLoginRequired → docPath */
-export declare function defaultAuthSkip(request: FastifyRequest, ctx: MiddlewareContext<unknown, unknown>): boolean;
-export declare function createAuthMiddleware<C = unknown, S = unknown>(ctx: MiddlewareContext<C, S>, options?: AuthMiddlewareOptions<C, S>): MiddlewareUnit;
-//# sourceMappingURL=auth.d.ts.map

package/output/app/middleware/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../source/app/middleware/auth.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;;;;;;;GASG;AAEH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,wCAAwC;AACxC,MAAM,MAAM,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CAC/C,OAAO,EAAE,cAAc,EACvB,GAAG,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,KACzB,OAAO,GAAG,SAAS,CAAA;AAExB,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IAC7D;;;;OAIG;IACH,MAAM,CAAC,EAAE,CACP,KAAK,EAAE,eAAe,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,EAC5C,GAAG,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,KACzB,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAC9B,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,wCAAwC;IACxC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IACrB,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,CAAA;CACrC;AAmCD,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAgB1G;AAgFD,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,GAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAM,GAAG,cAAc,CAoGtJ"}

package/output/app/middleware/auth.js

@@ -1,190 +0,0 @@
-import { readConfigKey } from '../context.js';
-import { readServerIdentity } from '../core/identity.js';
-import { DOC_ROUTE_PREFIX } from '../core/openapi.js';
-import { SystemError, UserError } from '../errors.js';
-import { readRegisteredOperations, toPermissionOperations } from '../permission-operations.js';
-function readAccount(config) {
-    return readConfigKey(config, 'account');
-}
-function readServer(config) {
-    return readConfigKey(config, 'server');
-}
-function readCookieNames(config, fallback) {
-    if (fallback && fallback.length > 0) {
-        return fallback;
-    }
-    const configured = readServer(config)?.cookieNames;
-    return Array.isArray(configured) && configured.length > 0 ? configured : ['token'];
-}
-function extractAuth(request, cookieNames) {
-    const authorization = request.headers.authorization;
-    if (typeof authorization === 'string' && authorization.startsWith('Bearer ')) {
-        return { token: authorization.slice('Bearer '.length).trim() };
-    }
-    if (typeof authorization === 'string' && authorization.startsWith('apikey-')) {
-        return { apiKey: authorization.slice('apikey-'.length).trim() };
-    }
-    for (const name of cookieNames) {
-        const value = request.cookies?.[name];
-        if (typeof value === 'string' && value) {
-            return { token: value };
-        }
-    }
-    return {};
-}
-/** 框架默认 skip：OPTIONS → 未匹配路由 → NoLoginRequired → docPath */
-export function defaultAuthSkip(request, ctx) {
-    void ctx;
-    if (request.method === 'OPTIONS') {
-        return true;
-    }
-    const url = request.routeOptions?.url;
-    if (!url) {
-        return true;
-    }
-    if (url.startsWith(DOC_ROUTE_PREFIX)) {
-        return true;
-    }
-    if (request.routeOptions?.config?.accessControls?.includes('NoLoginRequired')) {
-        return true;
-    }
-    return false;
-}
-async function defaultVerify(input, account) {
-    const serviceUrl = account?.serviceUrl;
-    if (!serviceUrl) {
-        // 内置 verify 依赖 account `serviceUrl`；缺失时抛明确错误
-        // （不再 `new URL(path, undefined)` 抛 TypeError）
-        throw new SystemError('CONFIG_UNAVAILABLE', undefined, 'account 未配置 serviceUrl，无法使用内置 verify（可用 verify 选项整体替换校验实现）');
-    }
-    const target = new URL('/gateway/verify', serviceUrl);
-    const response = await fetch(target, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-            token: input.token,
-            apiKey: input.apiKey,
-            service: input.service,
-            operation: input.operation,
-            resource: input.resource,
-            accessControls: input.accessControls,
-            metadata: input.metadata,
-        }),
-    });
-    const payload = (await response.json());
-    if (!response.ok || payload.status !== 'SUCCESS') {
-        throw new UserError(payload.status ?? 'AUTH_FAILED', undefined, payload.message ?? '');
-    }
-    return { user: payload.data?.user, token: payload.data?.token ?? input.token };
-}
-/** account 权限操作注册端点（固定路径） */
-const PERMISSION_OPERATION_REGISTER_PATH = '/permission/operation/register';
-/**
- * 框架内置 account HTTP 客户端：`POST /permission/operation/register`。
- *
- * 成功判定与 `/gateway/verify` 同口径：HTTP ok **且** 信封 `status === 'SUCCESS'`。
- */
-async function requestPermissionRegistration(account, body) {
-    const target = new URL(PERMISSION_OPERATION_REGISTER_PATH, account.serviceUrl);
-    const response = await fetch(target, {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    const payload = (await response.json().catch(() => undefined));
-    if (!response.ok || payload?.status !== 'SUCCESS') {
-        throw new SystemError('EXTERNAL_SERVICE_ERROR', { cause: response }, payload?.message ?? `权限操作注册失败（HTTP ${response.status}）`);
-    }
-}
-export function createAuthMiddleware(ctx, options = {}) {
-    const skip = options.skip ?? defaultAuthSkip;
-    const mapError = options.mapError ??
-        ((error) => UserError.is(error) || SystemError.is(error)
-            ? error
-            : new SystemError('EXTERNAL_SERVICE_ERROR', { cause: error }));
-    return {
-        name: 'auth',
-        register: (app) => {
-            const identity = readServerIdentity(app);
-            const service = identity?.service ?? '';
-            app.addHook('preValidation', async (request) => {
-                if (skip(request, ctx)) {
-                    return;
-                }
-                const account = readAccount(ctx.config);
-                // account `serviceUrl` 门槛仅作用于内置 verify：自定义 verify 不受约束，仍照常校验
-                if (!options.verify && !account?.serviceUrl) {
-                    return;
-                }
-                const { token, apiKey } = extractAuth(request, readCookieNames(ctx.config, options.cookieNames));
-                if (!token && !apiKey) {
-                    throw new UserError('INVALID_TOKEN', undefined, '缺少访问凭证');
-                }
-                const verifyInput = {
-                    token,
-                    apiKey,
-                    service,
-                    // 权限目录同源、与 url 解耦：优先路由 `schema.operationId`，未声明时回落 url
-                    operation: request.routeOptions?.schema?.operationId ?? request.routeOptions?.url,
-                    resource: request.params,
-                    accessControls: request.routeOptions?.config?.accessControls,
-                    metadata: {
-                        requestId: request.id,
-                        method: request.method,
-                        url: request.url,
-                        ip: request.ip,
-                        ips: request.ips,
-                        userAgent: request.headers['user-agent'],
-                        referrer: request.headers.referer,
-                    },
-                };
-                try {
-                    const result = options.verify
-                        ? await options.verify(verifyInput, ctx)
-                        : await defaultVerify(verifyInput, account);
-                    request.user = result.user;
-                    request.token = result.token;
-                }
-                catch (error) {
-                    throw mapError(error);
-                }
-            });
-            if (options.registerPermissions === false) {
-                return;
-            }
-            app.addHook('onReady', async () => {
-                let account;
-                try {
-                    account = readAccount(ctx.config);
-                }
-                catch (error) {
-                    if (SystemError.is(error) && error.type === 'CONFIG_UNAVAILABLE') {
-                        // 出 spec 路径（generateOpenApi 不跑 config 槽位）：配置不可用 → 跳过自注册
-                        return;
-                    }
-                    ctx.log.error({ error }, '[PermissionOperation][auth] read account config failed');
-                    return;
-                }
-                // 未配置 account `serviceUrl`（含 account 自身）→ 不注册
-                if (!account?.serviceUrl) {
-                    return;
-                }
-                try {
-                    const operations = toPermissionOperations(readRegisteredOperations(app));
-                    if (operations.length === 0) {
-                        return;
-                    }
-                    await requestPermissionRegistration(account, {
-                        service,
-                        version: identity?.version ?? '',
-                        operations,
-                    });
-                }
-                catch (error) {
-                    // 失败不致命：只记日志、继续启动（不得抛错中断）
-                    ctx.log.error({ error }, '[PermissionOperation][auth] self-registration failed');
-                }
-            });
-        },
-    };
-}

package/output/app/middleware/context.d.ts

@@ -1,13 +0,0 @@
-import type { MiddlewareUnit } from '../types.js';
-/**
- * 标准中间件单元 `context`（可替换）。
- *
- * `decorateRequest(decorateAs, ...)`（默认 `'ctx'`），消费既有 `context/createContext`。
- * 装饰必须在 `ready()` 之前注册（`register` 期完成）。
- */
-export interface ContextMiddlewareOptions {
-    /** 默认 `'ctx'` */
-    decorateAs?: string;
-}
-export declare function createContextMiddleware(options?: ContextMiddlewareOptions): MiddlewareUnit;
-//# sourceMappingURL=context.d.ts.map