M1: 底座 —— @contracts 首版 + event / ledger / org / llm

@contracts 首版(§8.1 九个文件):
- id 品牌 ID / terminal 终态五名与归侧四标签 / envelope 信封六字段与四类事件
- card 工单两模式 + 对话卡族(形状对齐 2026-07-26 原型定稿)
- contract7 契约七件 / ledger 三级寻址与写三分 / process-package 流程包 DSL 与触发器三类
- manifest 活动包清单六区(含 CMMN·DMN·步序声明的资产形状)/ org / api 路由契约

模块(L1):
- event   信封存储、归属解析三级短路、投递五诺、监听注册表、三级消费裁定
- ledger  schema 自生长(最大化合并/最宽类型/只增不破坏)、任务视图叠加、写三分、冲突检查
- org     岗位授权(客体三类×动作三种)、停用前置检查、会话、种子播种
- llm     四元绑定、ModelGateway 三模式(live/record/replay)—— 两缝之一

app 装配:Hono 服务 + 鉴权中间件 + 治理台/工作台路由;drizzle 迁移;AES-256-GCM 凭证密封

ADR-007 工具链与门禁 · ADR-008 投递队列 · ADR-009 凭证加密
(ADR 编号自 007 续:编码规范 §14 已用到 006,README 写「从 005 续」是笔误)

门禁五道全绿;96 个测试通过,含对真实 PG 的 ledger 集成测试

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KeDBx2PHLavbURXB8LJJ7m
This commit is contained in:
JCAI Main Agent
2026-07-27 00:59:14 +08:00
co-authored by Claude Opus 5
parent 7cd664af3a
commit 14d4fa046a
120 changed files with 15236 additions and 78 deletions
+46
View File
@@ -0,0 +1,46 @@
/**
* module: event —— 对外类型(编码规范 §10.1)。
*/
import type { Delivery, Envelope, EnvelopeDraft, EventId, ListenerId, ListenerSpec, OwnershipResolution, PositionId, RegisteredListener, TaskId } from '@contracts';
import type { InboundFacts, OutboundRef, OwnershipKeyRules } from './internal/domain/ownership.ts';
import type { ConsumptionPlan } from './internal/domain/delivery.ts';
export type { Delivery, Envelope, EnvelopeDraft, ListenerSpec, OwnershipResolution, RegisteredListener };
export type { InboundFacts, OutboundRef, OwnershipKeyRules, ConsumptionPlan };
export declare class ListenerDeadlineError extends Error {
readonly detail: string;
constructor(detail: string);
}
/** 发布结果 —— 三级消费的判定结果,ingest 路由据此回执 */
export type PublishResult = {
readonly eventId: EventId;
readonly plan: ConsumptionPlan;
};
export type InboundResult = PublishResult & {
readonly resolution: OwnershipResolution;
};
export type EventService = {
/** 先持久后投递:信封落 sys.event 与入队在同一事务 */
publish(draft: EnvelopeDraft): Promise<PublishResult>;
/** 通道入站:归属解析 → 归一 → 抛数据事件 */
ingestInbound(input: {
readonly facts: InboundFacts;
readonly rules: OwnershipKeyRules;
readonly draft: EnvelopeDraft;
}): Promise<InboundResult>;
getEvent(id: EventId): Promise<Envelope | undefined>;
listByTask(taskId: TaskId, limit?: number): Promise<Envelope[]>;
/** 监听注册表 —— 时限必配,注册即校验 */
registerListener(taskId: TaskId, spec: ListenerSpec): Promise<RegisteredListener>;
cancelListener(id: ListenerId): Promise<void>;
listListeners(taskId: TaskId): Promise<RegisteredListener[]>;
/** 到期扫描:抛时间事件,按阶梯催办 */
sweepExpiredListeners(): Promise<RegisteredListener[]>;
/** 出站关联记录 —— 归属解析①③级的对表来源 */
recordOutbound(ref: OutboundRef): Promise<void>;
/** 消费幂等:事件 ID × 消费者;已消费返回 false */
claimConsumption(eventId: EventId, consumer: string): Promise<boolean>;
/** 投递失败回执:重试或入死信 */
reportFailure(deliveryId: string, error: string): Promise<Delivery>;
};
/** 无主兜底的收件岗位 —— 由通道实例配置给出 */
export type FallbackPosition = PositionId;
+14
View File
@@ -0,0 +1,14 @@
/**
* module: event —— 唯一出口。只做 re-export,不写逻辑(编码规范 §10.1)。
*/
export type { ConsumptionPlan, Delivery, Envelope, EnvelopeDraft, EventService, InboundFacts, InboundResult, ListenerSpec, OutboundRef, OwnershipKeyRules, OwnershipResolution, PublishResult, RegisteredListener, } from './contract.ts';
export { ListenerDeadlineError } from './contract.ts';
export type { Clock, ConditionEvaluator, EventStore, IdGenerator, MessageFallback, TriggerMatcher, } from './port.ts';
export type { EventServiceDeps } from './internal/usecase/event-service.ts';
export { createEventService } from './internal/usecase/event-service.ts';
export type { RetryDecision, RetryPolicy } from './internal/domain/delivery.ts';
export { consumptionKey, DEFAULT_RETRY, decideRetry, fanOutTargets, planConsumption, } from './internal/domain/delivery.ts';
export { deadlineMillis, matchesFilter, matchesListener, matchingListeners, scopeOf } from './internal/domain/listener-match.ts';
export { extractKeys, resolveOwnership } from './internal/domain/ownership.ts';
export { claimPendingDeliveries, createEventStore } from './internal/adapter/event-store.ts';
export { consumptionTable, deliveryTable, eventTable, listenerTable, outboundRefTable, } from './internal/adapter/event-schema.ts';
+45
View File
@@ -0,0 +1,45 @@
/**
* module: event —— 本模块要外界提供的能力(编码规范 §10.1 / §5.3)。
*
* 注意层级:event 是 L1,而任务(L6)、触发器(L7)、消息(L2)都在其上 —— 三级消费的
* 三个下游一律以**端口**声明、由 app 装配注入,event 不反向依赖上层(§4 / §5.2)。
*/
import type { Delivery, Envelope, EventId, RegisteredListener, TaskId } from '@contracts';
import type { OutboundRef } from './internal/domain/ownership.ts';
import type { ConditionEvaluator } from './internal/domain/listener-match.ts';
export type Clock = {
now(): Date;
};
export type IdGenerator = {
next(): string;
};
export type { ConditionEvaluator };
/** 事件存储 —— 「先持久后投递」的底座 */
export type EventStore = {
/** 信封落库与入队同一事务 */
persistAndEnqueue(envelope: Envelope, targets: readonly Delivery[]): Promise<void>;
get(id: EventId): Promise<Envelope | undefined>;
listByTask(taskId: TaskId, limit: number): Promise<Envelope[]>;
listenersOf(taskId: TaskId): Promise<RegisteredListener[]>;
/** 全部 armed 监听 —— 事件到达时的匹配面 */
armedListeners(): Promise<RegisteredListener[]>;
saveListener(listener: RegisteredListener): Promise<void>;
setListenerState(id: string, state: RegisteredListener['state']): Promise<void>;
expiredListeners(now: Date): Promise<RegisteredListener[]>;
saveOutbound(ref: OutboundRef): Promise<void>;
recentOutbound(sinceMs: number, now: Date): Promise<OutboundRef[]>;
/** 消费幂等表:唯一约束成功返回 true,冲突返回 false */
claimConsumption(eventId: EventId, consumer: string): Promise<boolean>;
getDelivery(id: string): Promise<Delivery | undefined>;
updateDelivery(delivery: Delivery): Promise<void>;
scheduleRetry(deliveryId: string, delayMs: number): Promise<void>;
};
/** 触发器判定 —— app 注入 `trigger`(L7)的只读用例;返回命中的触发器 ID */
export type TriggerMatcher = {
match(envelope: Envelope): Promise<string[]>;
};
/** 死信与无主兜底 —— app 注入 `message`(L2) */
export type MessageFallback = {
deadLetter(envelope: Envelope, error: string): Promise<void>;
unowned(envelope: Envelope, fallbackPosition: string | undefined): Promise<void>;
};
+75
View File
@@ -0,0 +1,75 @@
/**
* module: ledger —— 对外类型(编码规范 §10.1)。只有类型和常量,没有实现。
*/
import type { LedgerAddress, LedgerKey, LedgerPage, LedgerQuery, LedgerRow, ObjectDeclaration, TaskId, WriteKind } from '@contracts';
import type { MaterializedObject, MergeConflict, MergeNotice, MergedObject } from './internal/domain/schema-merge.ts';
import type { ConflictFinding } from './internal/domain/task-view.ts';
export type { LedgerAddress, LedgerKey, LedgerPage, LedgerQuery, LedgerRow, ObjectDeclaration, WriteKind };
export type { MaterializedObject, MergeConflict, MergeNotice, MergedObject, ConflictFinding };
export declare class DraftConflictError extends Error {
readonly findings: readonly ConflictFinding[];
constructor(findings: readonly ConflictFinding[]);
}
export declare class SchemaConflictError extends Error {
readonly conflicts: readonly MergeConflict[];
constructor(conflicts: readonly MergeConflict[]);
}
export declare class ObjectNotMaterializedError extends Error {
readonly address: string;
constructor(address: string);
}
/** 声明合并与物化的结果 —— 安装静态审读它:conflicts 非空即不上架 */
export type SchemaApplyResult = {
readonly merged: MergedObject | undefined;
readonly notices: readonly MergeNotice[];
readonly conflicts: readonly MergeConflict[];
readonly applied: boolean;
};
export type ObjectAddress = {
readonly domain: string;
readonly object: string;
};
export type SystemWrite = {
readonly address: ObjectAddress;
readonly key: LedgerKey;
readonly values: LedgerRow;
/** 归因:哪条入站 / 哪次流转产生了这次系统写 */
readonly cause: {
readonly kind: 'inbound' | 'engine' | 'governance';
readonly ref: string;
};
/** 系统写也可挂到任务上(入站归一到某任务),数据事件的目标即它 */
readonly taskId?: TaskId;
};
export type DraftWrite = {
readonly taskId: TaskId;
readonly address: ObjectAddress;
readonly key: LedgerKey;
readonly patch: LedgerRow;
readonly tombstone?: boolean;
};
export type ReleaseWriteResult = {
readonly mergedRows: number;
readonly emittedEvents: number;
};
/**
* 写三分是**三个不同方法**,不是一个带 flag 的方法 —— 调用方拿不到「绕门」的形态(§7.2)。
* systemWrite —— 登记世界已发生的事实,不过放行门,写正式版并**即时**抛数据事件
* draftWrite —— 任务级草稿层,读己之写,**不抛**事件
* releaseWrite —— 放行通过,草稿合并入正式版,**此刻**抛数据事件;原子且过冲突检查
*/
export type LedgerService = {
applyDeclarations(declarations: readonly ObjectDeclaration[]): Promise<SchemaApplyResult[]>;
describe(address: ObjectAddress): Promise<MaterializedObject | undefined>;
listObjects(): Promise<ObjectAddress[]>;
systemWrite(write: SystemWrite): Promise<void>;
draftWrite(write: DraftWrite): Promise<void>;
releaseWrite(taskId: TaskId): Promise<ReleaseWriteResult>;
/** 正式版查询 —— 跨任务只见过门的事实 */
query(query: LedgerQuery): Promise<LedgerPage>;
/** 任务视图 = 正式版 + 本任务草稿层 */
taskView(taskId: TaskId, query: LedgerQuery): Promise<LedgerPage>;
/** 落地预检第五项:数据冲突检查 */
checkConflicts(taskId: TaskId): Promise<ConflictFinding[]>;
discardDrafts(taskId: TaskId): Promise<void>;
};
+13
View File
@@ -0,0 +1,13 @@
/**
* module: ledger —— 唯一出口。只做 re-export,不写逻辑(编码规范 §10.1)。
*/
export type { ConflictFinding, DraftWrite, LedgerAddress, LedgerKey, LedgerPage, LedgerQuery, LedgerRow, LedgerService, MaterializedObject, MergeConflict, MergeNotice, MergedObject, ObjectAddress, ObjectDeclaration, ReleaseWriteResult, SchemaApplyResult, SystemWrite, WriteKind, } from './contract.ts';
export { DraftConflictError, ObjectNotMaterializedError, SchemaConflictError } from './contract.ts';
export type { Clock, DraftStore, EventPublisher, IdGenerator, LedgerStore, ObjectRef } from './port.ts';
export type { LedgerServiceDeps } from './internal/usecase/ledger-service.ts';
export { createLedgerService } from './internal/usecase/ledger-service.ts';
export type { MergedField, SchemaChange, SchemaPlan, WidenResult, } from './internal/domain/schema-merge.ts';
export { mergeDeclarations, planIsNonDestructive, planSchemaChanges, widen, } from './internal/domain/schema-merge.ts';
export type { DraftEntry } from './internal/domain/task-view.ts';
export { detectConflicts, keyOf, overlay, pickKey } from './internal/domain/task-view.ts';
export { createDraftStore, createLedgerStore, DRAFT_DDL, DRAFT_TABLE, tableNameOf } from './internal/adapter/ledger-store.ts';
+47
View File
@@ -0,0 +1,47 @@
/**
* module: ledger —— 本模块要外界提供的能力(编码规范 §10.1 / §5.3)。
*/
import type { EnvelopeDraft, LedgerKey, LedgerQuery, LedgerRow } from '@contracts';
import type { MaterializedObject, SchemaChange } from './internal/domain/schema-merge.ts';
import type { DraftEntry } from './internal/domain/task-view.ts';
export type Clock = {
now(): Date;
};
export type IdGenerator = {
next(): string;
};
/** 数据事件的发射口 —— app 注入 `event` 模块的出口(§5.2) */
export type EventPublisher = {
publish(envelope: EnvelopeDraft): Promise<void>;
};
export type ObjectRef = {
readonly domain: string;
readonly object: string;
};
/**
* 台账存储 —— 运行时 DDL / DML 由声明生成,ORM 静态 schema 不适用,
* 一律 node-postgres 直写(§1 / ADR-002)。
*/
export type LedgerStore = {
/** 已物化对象的列与主键;未物化返回 undefined */
describe(ref: ObjectRef): Promise<MaterializedObject | undefined>;
listObjects(): Promise<ObjectRef[]>;
/** 执行「只增不破坏」的变更计划 */
applyChanges(ref: ObjectRef, changes: readonly SchemaChange[]): Promise<void>;
select(query: LedgerQuery): Promise<{
rows: LedgerRow[];
total: number;
}>;
selectByKeys(ref: ObjectRef, keys: readonly LedgerKey[]): Promise<LedgerRow[]>;
upsert(ref: ObjectRef, key: LedgerKey, values: LedgerRow): Promise<void>;
deleteRow(ref: ObjectRef, key: LedgerKey): Promise<void>;
/** 放行写的原子性:草稿合并与事件登记同一事务 */
transaction<T>(fn: (store: LedgerStore, drafts: DraftStore) => Promise<T>): Promise<T>;
};
/** 任务级草稿层 —— 推荐形态 ledger.__draft;物理形态可换,功能约束不可变(§7.2) */
export type DraftStore = {
list(taskId: string): Promise<Array<DraftEntry & ObjectRef>>;
listForObject(taskId: string, ref: ObjectRef): Promise<DraftEntry[]>;
put(taskId: string, ref: ObjectRef, entry: DraftEntry): Promise<void>;
clear(taskId: string): Promise<void>;
};
+98
View File
@@ -0,0 +1,98 @@
/**
* module: llm —— 对外类型(编码规范 §10.1)。
*
* 两条缝之一(§7.3):`ModelGateway` 支持 record | replay | live 三模式 ——
* **任何模型调用不经 ModelGateway,回放审就对它失明**(§12.5#10)。
*/
import type { LlmInstanceView, LlmProvider, TaskId } from '@contracts';
import type { ModelBinding, BindingViolation } from './internal/domain/model-binding.ts';
export type { LlmInstanceView, LlmProvider, ModelBinding, BindingViolation };
/** 一条缝的三个开关位 */
export declare const GATEWAY_MODES: readonly ["live", "record", "replay"];
export type GatewayMode = (typeof GATEWAY_MODES)[number];
export declare class ModelNotBoundError extends Error {
readonly modelName: string;
readonly violations: readonly BindingViolation[];
constructor(modelName: string, violations: readonly BindingViolation[]);
}
export declare class ModelDisabledError extends Error {
readonly modelName: string;
constructor(modelName: string);
}
export declare class ReplayMissError extends Error {
readonly key: string;
constructor(key: string);
}
/** 模型调用的语义入参 —— 录制的就是它,不含任何凭证(ADR-009 #5) */
export type ModelCall = {
/** 活动声明的自定义模型名(逻辑名) */
readonly model: string;
readonly system?: string;
readonly prompt: string;
readonly temperature?: number;
readonly maxOutputTokens?: number;
/** 出参 schema(JSON Schema);给定即要求结构化出参并校验 */
readonly outputSchema?: Record<string, unknown>;
/** 录制/回放的定位:任务 × 步序号(§7.3) */
readonly taskId?: TaskId;
readonly stepNo?: number;
/** 归因用:调用点标签(flow 步名 / loop 回合 / 系统用途) */
readonly label?: string;
};
export type ModelUsage = {
readonly inputTokens: number;
readonly outputTokens: number;
readonly latencyMs: number;
};
export type ModelResult = {
readonly text: string;
/** outputSchema 给定时的解析结果 */
readonly object?: unknown;
readonly usage: ModelUsage;
/** 行为可归因:模型与版本记入留痕(OS 4.1) */
readonly binding: {
readonly name: string;
readonly provider: LlmProvider;
readonly model: string;
};
readonly mode: GatewayMode;
};
/**
* 模型网关 —— 活动基座六件里的「LLM 调用」。
* 活动只见自定义模型名;解析、凭证、录制回放全在此。
*/
export type ModelGateway = {
readonly mode: GatewayMode;
generate(call: ModelCall): Promise<ModelResult>;
/** 换模式的网关 —— 回放审用 replay 模式重跑引擎(§7.3) */
withMode(mode: GatewayMode): ModelGateway;
};
export type UpsertLlmInstance = {
readonly id?: string | undefined;
readonly name: string;
readonly provider: LlmProvider;
readonly baseUrl: string;
readonly model: string;
/** 只写不读:留空表示保持原值 */
readonly apiKey?: string | undefined;
readonly systemUse: boolean;
readonly enabled: boolean;
};
export type LlmService = {
list(): Promise<LlmInstanceView[]>;
upsert(input: UpsertLlmInstance): Promise<LlmInstanceView>;
remove(id: string): Promise<void>;
/** 连通性探针 —— 治理台「测试连接」 */
probe(id: string): Promise<{
ok: boolean;
latencyMs?: number;
error?: string;
}>;
/** 安装静态审:核对活动声明的模型名已绑定(AM 11.3) */
assertNamesBound(names: readonly string[]): Promise<{
ok: boolean;
missing: string[];
}>;
/** 系统用途模型 —— 叙述性小结 / 汇报生成 / 蒸馏钩子 */
systemUseBinding(): Promise<ModelBinding | undefined>;
};
+15
View File
@@ -0,0 +1,15 @@
/**
* module: llm —— 唯一出口。只做 re-export,不写逻辑(编码规范 §10.1)。
*/
export type { BindingViolation, GatewayMode, LlmInstanceView, LlmProvider, LlmService, ModelBinding, ModelCall, ModelGateway, ModelResult, ModelUsage, UpsertLlmInstance, } from './contract.ts';
export { GATEWAY_MODES, ModelDisabledError, ModelNotBoundError, ReplayMissError } from './contract.ts';
export type { Clock, IdGenerator, LlmInstanceRepository, ProviderInvoker, ReplayRecord, ReplayStore, SecretBox, } from './port.ts';
export type { LlmServiceDeps } from './internal/usecase/llm-service.ts';
export { createLlmService } from './internal/usecase/llm-service.ts';
export type { ModelGatewayDeps } from './internal/usecase/model-gateway.ts';
export { createModelGateway } from './internal/usecase/model-gateway.ts';
export { isBound, pickSystemUse, toPublicView, validateBinding } from './internal/domain/model-binding.ts';
export { callFingerprint, replayKey, stableStringify } from './internal/domain/replay-key.ts';
export { createLlmInstanceRepository, createReplayStore } from './internal/adapter/llm-repository.ts';
export { createProviderInvoker, parseJsonLoose } from './internal/adapter/ai-sdk-provider.ts';
export { llmInstanceTable, replayModelTable } from './internal/adapter/llm-schema.ts';
+54
View File
@@ -0,0 +1,54 @@
/**
* module: llm —— 本模块要外界提供的能力(编码规范 §10.1 / §5.3)。
*/
import type { ModelBinding } from './internal/domain/model-binding.ts';
import type { ModelCall, ModelResult, ModelUsage } from './contract.ts';
export type Clock = {
now(): Date;
};
export type IdGenerator = {
next(): string;
};
/** 凭证密封 —— 明文永不进 domain(ADR-009) */
export type SecretBox = {
seal(plaintext: string): string;
open(cipher: string): string;
};
export type LlmInstanceRepository = {
list(): Promise<ModelBinding[]>;
findByName(name: string): Promise<ModelBinding | undefined>;
findById(id: string): Promise<ModelBinding | undefined>;
upsert(binding: ModelBinding): Promise<ModelBinding>;
remove(id: string): Promise<void>;
};
/** 录制回放存储:按任务 × 步序号(§7.3) */
export type ReplayRecord = {
readonly key: string;
readonly call: ModelCall;
readonly result: {
readonly text: string;
readonly object?: unknown;
readonly usage: ModelUsage;
};
readonly recordedAt: Date;
};
export type ReplayStore = {
put(record: ReplayRecord): Promise<void>;
get(key: string): Promise<ReplayRecord | undefined>;
};
/**
* Provider 工厂 —— Vercel AI SDK 只准出现在 adapter(§6.2 / §11.4)。
* usecase 只见本端口,拿不到任何 SDK 类型。
*/
export type ProviderInvoker = {
invoke(input: {
readonly binding: ModelBinding;
readonly apiKey: string;
readonly call: ModelCall;
}): Promise<{
text: string;
object?: unknown;
usage: ModelUsage;
}>;
};
export type { ModelCall, ModelResult };
+52
View File
@@ -0,0 +1,52 @@
/**
* module: org —— 对外类型(编码规范 §10.1)。只有类型和常量,没有实现。
*/
import type { DisableCheck, Grant, GrantAction, GrantObject, Position, Session, Staff, StaffId } from '@contracts';
export type { DisableCheck, Grant, GrantAction, GrantObject, Position, Session, Staff };
/** 员工连同其岗位的读模型 —— 治理台员工管理列表用 */
export type StaffWithPosition = Staff & {
readonly position: Position;
};
export type CreateStaffInput = {
readonly account: string;
readonly name: string;
readonly positionId: string;
};
export declare class StaffNotFoundError extends Error {
readonly staffId: StaffId;
constructor(staffId: StaffId);
}
export declare class PositionNotFoundError extends Error {
readonly positionCode: string;
constructor(positionCode: string);
}
export declare class AccountTakenError extends Error {
readonly account: string;
constructor(account: string);
}
/** 停用前置检查未过:在途任务与待答卡须先改派完毕(OS 02) */
export declare class DisableBlockedError extends Error {
readonly check: DisableCheck;
constructor(check: DisableCheck);
}
export type OrgService = {
listStaff(): Promise<{
staff: StaffWithPosition[];
positions: Position[];
}>;
getStaff(staffId: StaffId): Promise<StaffWithPosition>;
findByAccount(account: string): Promise<StaffWithPosition | undefined>;
createStaff(input: CreateStaffInput): Promise<Staff>;
/** 停用前置检查 —— 只读,治理台先看再点 */
checkDisable(staffId: StaffId): Promise<DisableCheck>;
/** 停用 —— 前置检查不过即抛 DisableBlockedError,不做部分执行 */
disableStaff(staffId: StaffId): Promise<void>;
listGrants(positionId: string): Promise<Grant[]>;
setGrants(positionId: string, grants: readonly Grant[]): Promise<Grant[]>;
/** 岗位权限校验 —— app 层鉴权中间件读它 */
authorize(staffId: StaffId, object: GrantObject, action: GrantAction): Promise<boolean>;
loadSession(account: string): Promise<Session | undefined>;
/** 岗位在岗人员 —— 负责人四策略解析的候选集来源(由 process 调用) */
staffOfPosition(positionCode: string): Promise<StaffWithPosition[]>;
ensureSeeded(): Promise<void>;
};
+12
View File
@@ -0,0 +1,12 @@
/**
* module: org —— 唯一出口。只做 re-export,不写逻辑(编码规范 §10.1)。
*/
export type { CreateStaffInput, DisableCheck, Grant, GrantAction, GrantObject, OrgService, Position, Session, Staff, StaffWithPosition, } from './contract.ts';
export { AccountTakenError, DisableBlockedError, PositionNotFoundError, StaffNotFoundError, } from './contract.ts';
export type { Clock, GrantRepository, IdGenerator, InFlightWorkProbe, PositionRepository, StaffRepository, } from './port.ts';
export type { OrgServiceDeps } from './internal/usecase/org-service.ts';
export { createOrgService } from './internal/usecase/org-service.ts';
export { isAuthorized, actionCovers, objectCovers } from './internal/domain/authorization.ts';
export { DEFAULT_LOGIN_ACCOUNT, POSITION_SEED, STAFF_SEED } from './internal/domain/seed-data.ts';
export { createGrantRepository, createPositionRepository, createStaffRepository, objectKeyOf, } from './internal/adapter/org-repository.ts';
export { grantTable, positionTable, staffTable } from './internal/adapter/org-schema.ts';
+50
View File
@@ -0,0 +1,50 @@
/**
* module: org —— 本模块要外界提供的能力(编码规范 §10.1 / §5.3)。
* adapter 实现之,usecase 依赖之,app 装配之。
*/
import type { Grant, Position, PositionId, Staff, StaffId } from '@contracts';
export type Clock = {
now(): Date;
};
export type PositionRepository = {
list(): Promise<Position[]>;
findByCode(code: string): Promise<Position | undefined>;
findById(id: PositionId): Promise<Position | undefined>;
upsert(position: Omit<Position, 'id'> & {
id?: PositionId;
}): Promise<Position>;
};
export type StaffRepository = {
list(): Promise<Staff[]>;
findById(id: StaffId): Promise<Staff | undefined>;
findByAccount(account: string): Promise<Staff | undefined>;
listByPosition(positionId: PositionId): Promise<Staff[]>;
insert(staff: Staff): Promise<Staff>;
setState(id: StaffId, state: Staff['state']): Promise<void>;
};
export type GrantRepository = {
listByPosition(positionId: PositionId): Promise<Grant[]>;
replaceForPosition(positionId: PositionId, grants: readonly Grant[]): Promise<Grant[]>;
};
/**
* 在途工作探针 —— 停用前置检查要问的是 L6 `task` 与 L3 `human-tool`,
* 二者层级高于 org,故一律经本端口由 app 注入(编码规范 §5.2 同层/跨层协作规矩)。
*/
export type InFlightWorkProbe = {
openTasksOf(staffId: StaffId): Promise<Array<{
taskId: string;
title: string;
}>>;
openCardsOf(staffId: StaffId): Promise<Array<{
cardId: string;
title: string;
}>>;
openApprovalsOf(staffId: StaffId): Promise<Array<{
approvalId: string;
title: string;
}>>;
};
/** ID 生成 —— domain 零随机(§5.3) */
export type IdGenerator = {
next(): string;
};