precis-cli 0.1.3__py3-none-any.whl

app/shared/core/project/constraint/factory.py

@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 约束实例化工厂模块
+
+功能概述:
+- 根据 ConstraintFile 配置创建运行时约束对象
+- 处理约束引用解析（table_id -> table_name, column_id -> column_name）
+- 支持批量创建多个约束对象
+
+架构设计:
+- 工厂模式: 根据约束类型名称动态实例化对应约束类
+- 可注册构建器: 各约束类型的参数构建逻辑封装在 builders/ 子包中，
+  通过 @register_builder 自注册（参考前端 nodeDataBuilder 模式）
+- 依赖注册表: 使用 registry.py 获取约束类型到实现类的映射
+- 参数过滤: 使用 filter_kwargs_for_class 过滤仅构造函数接受的参数
+
+输入示例:
+    constraint = ConstraintFile(
+        version=2,
+        id="unique_email",
+        type="Unique",
+        enabled=True,
+        refs={"table_id": "users", "column_ids": ["email"]},
+        params={},
+    )
+
+输出示例:
+    runtime_constraint, error = create_constraint(constraint, schema_files)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from ..schema.types_parts.column_utils import build_column_id_to_name_map
+
+logger = logging.getLogger(__name__)
+
+# 导入约束注册表和工具函数，用于根据类型名称查找约束类并过滤参数
+# side-effect import 触发各 builder 的 @register_builder 注册
+from . import builders as _builders  # noqa: F401
+from .builders import BuilderInput, build_kwargs
+from .registry import filter_kwargs_for_class, normalize_constraint_type, resolve_constraint_class
+from .types import ConstraintFile
+
+if TYPE_CHECKING:
+    # 仅在类型检查阶段导入 Schema 类型，避免运行时循环依赖
+    from ..schema.types import TableSchemaFile
+
+
+def create_constraint(
+    const: ConstraintFile,
+    schema_files: dict[str, TableSchemaFile],
+) -> tuple[Any | None, str | None]:
+    """
+    @methoddesc 根据 ConstraintFile 创建运行时约束对象。
+
+    该函数执行以下步骤：
+    1. 检查约束是否启用，未启用则返回 None
+    2. 规范化约束类型名称，从注册表获取对应的约束类
+    3. 构建 column_id -> column_name 映射 + BuilderInput 上下文
+    4. 调用 build_kwargs 委托给各类型的注册构建器（消除 if-elif 链）
+    5. 过滤参数，只保留约束类构造函数接受的参数
+    6. 实例化约束类并返回
+
+    :param const: ConstraintFile 配置对象，包含约束的完整配置
+    :param schema_files: schema 文件字典，键为 table_id，值为 TableSchemaFile 对象
+    :return: (约束实例对象, 错误信息)。若成功，错误信息为 None；若失败，实例为 None；若未启用，两者均为 None。
+    """
+    # 步骤1：检查约束是否启用，未启用则跳过
+    if not const.enabled:
+        return None, None
+
+    # 步骤2：规范化约束类型名称（如 "unique" -> "Unique"），从注册表延迟解析对应的约束类
+    type_name = normalize_constraint_type(const.type)
+    constraint_class = resolve_constraint_class(type_name)
+    if constraint_class is None:
+        return None, f"不支持的约束类型: {const.type}（规范化后: {type_name}）"
+
+    refs = const.refs or {}
+    params = const.params or {}
+
+    # 构建 column_id -> column_name 映射表（按 table_id 分组,递归含嵌套 children）
+    # 结构：{table_id: {column_id: column_name, ...}, ...}
+    # 注:递归遍历确保 JSON 嵌套子列上的约束也能解析列引用
+    column_name_by_table_id: dict[str, dict[str, str]] = {
+        sid: build_column_id_to_name_map(s.columns) for sid, s in schema_files.items()
+    }
+
+    # 检查约束引用的表是否存在
+    table_id = refs.get("table_id") or refs.get("from_table_id")
+    if table_id and table_id not in schema_files:
+        return None, f"引用的表 '{table_id}' 不存在（可能已被删除）"
+
+    # 步骤3-4：构建 BuilderInput 并委托给注册构建器（Composite 的递归通过 create_child 回调注入）
+    inp = BuilderInput(
+        const=const,
+        refs=refs,
+        params=params,
+        column_name_by_table_id=column_name_by_table_id,
+        schema_files=schema_files,
+        create_child=create_constraint,  # 依赖注入：Composite builder 用此回调递归，避免循环 import
+    )
+    result = build_kwargs(type_name, inp)
+    if result is None:
+        # 未注册的类型：返回错误（此前 Charset 走通用路径是隐性 bug，现已补 builder）
+        return None, f"不支持的约束类型: {const.type}（规范化后: {type_name}）"
+    kwargs, error = result
+    if error:
+        return None, error
+
+    # 步骤5：过滤 kwargs，只保留约束类构造函数接受的参数
+    filtered = filter_kwargs_for_class(constraint_class, kwargs)
+
+    # 步骤6：实例化约束类并返回
+    return constraint_class(**filtered), None
+
+
+def create_constraints(
+    constraint_files: dict[str, ConstraintFile],
+    schema_files: dict[str, TableSchemaFile],
+) -> tuple[list[Any], list[str]]:
+    """
+    @methoddesc 批量创建运行时约束对象。
+
+    遍历所有约束配置文件，调用 create_constraint 进行转换，
+    过滤掉未启用的约束，返回所有启用的约束实例列表。
+
+    :param constraint_files: 约束配置字典，键为 constraint_id，值为 ConstraintFile 对象
+    :param schema_files: schema 文件字典，键为 table_id，值为 TableSchemaFile 对象
+    :return: (约束实例列表, 警告信息列表)
+    """
+    # 初始化结果列表
+    constraints: list[Any] = []
+    warnings: list[str] = []
+
+    # 遍历所有约束配置
+    for const in constraint_files.values():
+        try:
+            # 创建单个约束实例
+            constraint, error = create_constraint(const, schema_files)
+            # 仅添加非 None 的约束（即已启用的约束）
+            if constraint is not None:
+                # P0-3: 在实例上挂约束 ID（运行时对象不参与序列化回写），
+                # 供调用方（executor）将错误回溯到来源约束文件
+                constraint.constraint_id = const.id  # type: ignore[attr-defined]
+                constraints.append(constraint)
+            elif error:
+                # 收集警告信息
+                warnings.append(f"约束「{const.description or const.id}」配置有误（{error}），本次校验已跳过它")
+            # else: 约束未启用，忽略
+        except Exception as e:
+            warnings.append(f"约束「{const.description or const.id}」加载时出现异常（{str(e)}），本次校验已跳过它")
+
+    return constraints, warnings

app/shared/core/project/constraint/reader.py

@@ -0,0 +1,214 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 约束规则读取模块
+
+功能概述:
+- 从 *.constraint.yaml 文件读取约束配置
+- 验证约束配置文件的格式和内容
+- 支持批量加载多个约束配置文件
+
+架构设计:
+- 读取层: 将 YAML 配置文件解析为程序可用的 Python 对象
+- 数据验证: 使用 Pydantic 确保配置文件格式正确
+- 读写配合: 与 writer.py 配合实现约束配置全生命周期管理
+
+输入示例:
+    # users.constraint.yaml
+    version: 2
+    id: unique_email
+    type: Unique
+    enabled: true
+    refs:
+      table_id: users
+      column_ids: [email]
+
+输出示例:
+    constraint = load_constraint("users.constraint.yaml")
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pydantic import ValidationError
+
+# 导入底层的 YAML 读取工具
+from app.shared.core.io.yaml import read_yaml
+
+# 导入约束配置的数据模型
+from .types import ConstraintFile
+
+if TYPE_CHECKING:
+    # 仅在类型检查阶段导入，避免运行时循环依赖
+    from .types import ConstraintFile
+
+
+def load_constraint(constraint_path: str | Path) -> ConstraintFile:
+    """
+    @methoddesc 从 YAML 文件加载约束配置。
+
+    ============================================================================
+    配置文件示例 (本函数处理的配置文件长这样)
+    ============================================================================
+    本函数处理以下格式的 *.constraint.yaml 文件：
+
+    ```yaml
+    # ============================================================
+    # 约束规则配置文件 (*.constraint.yaml)
+    # ============================================================
+
+    version: 2
+
+    id: unique_user_email
+
+    type: Unique
+
+    enabled: true
+
+    description: "用户邮箱必须唯一"
+
+    refs:
+      table_id: users
+      column_ids: [email]
+
+    params: {}
+    ```
+
+    ============================================================================
+    业务场景 (什么情况下会调用这个函数)
+    ============================================================================
+    - 场景1: 项目启动时加载约束配置
+      系统启动时需要加载所有约束配置文件，构建运行时约束对象。
+
+    - 场景2: 加载单个约束详情
+      用户在 UI 上查看某个约束的详细信息。
+
+    - 场景3: 约束配置导入验证
+      导入约束配置文件时，需要验证格式是否正确。
+
+    ============================================================================
+    数据流 (输入如何变成输出)
+    ============================================================================
+    输入参数:
+      - constraint_path: str | Path，constraint 文件路径
+        示例值: "constraints/unique_user_email.constraint.yaml"
+
+    处理步骤:
+      ┌─────────────────────────────────────────────────────────────┐
+      │ Step 1: 路径标准化                                      │
+      ├─────────────────────────────────────────────────────────────┤
+      │ 输入: 字符串或 Path 对象                                  │
+      │ 操作: 转换为 Path 对象                                    │
+      │ 输出: Path 对象                                          │
+      └─────────────────────────────────────────────────────────────┘
+
+      ┌─────────────────────────────────────────────────────────────┐
+      │ Step 2: YAML 解析                                       │
+      ├─────────────────────────────────────────────────────────────┤
+      │ 输入: Path 对象                                          │
+      │ 操作: 读取 YAML 文件                                     │
+      │ 输出: 字典对象                                           │
+      └─────────────────────────────────────────────────────────────┘
+
+      ┌─────────────────────────────────────────────────────────────┐
+      │ Step 3: Pydantic 验证                                  │
+      ├─────────────────────────────────────────────────────────────┤
+      │ 输入: 字典对象                                           │
+      │ 操作: 验证数据结构                                       │
+      │ 输出: ConstraintFile 对象                               │
+      └─────────────────────────────────────────────────────────────┘
+
+    最终输出: ConstraintFile 对象
+
+    ============================================================================
+    异常处理
+    ============================================================================
+    | 异常类型 | 触发条件 | 处理方式 |
+    |---------|---------|---------|
+    | FileNotFoundError | 文件不存在 | 检查文件路径 |
+    | ValueError | YAML 格式错误 | 验证 YAML 文件 |
+    | ValueError | 验证失败 | 检查配置格式 |
+
+    :param constraint_path: constraint 文件路径，可以是字符串或 Path 对象
+    :return: ConstraintFile 对象，包含验证后的约束配置数据
+    :raises ValueError: 文件不存在、格式错误或验证失败时抛出
+    :raises FileNotFoundError: 文件路径不存在时由 read_yaml 抛出
+    """
+    # 步骤1：标准化路径格式，兼容字符串和 Path 对象输入
+    path = Path(constraint_path)
+    # 步骤2：读取 YAML 文件原始内容（字典格式）
+    raw = read_yaml(path)
+    # 步骤3：使用 Pydantic 验证数据格式，确保必填字段存在且类型正确
+    try:
+        return ConstraintFile.model_validate(raw)
+    except ValidationError as e:
+        # 步骤4：验证失败时抛出带详细信息的 ValueError
+        raise ValueError(f"constraint 校验失败: {constraint_path}\n{e}") from e
+
+
+def load_constraints(constraint_paths: list) -> dict[str, ConstraintFile]:
+    """
+    @methoddesc 批量加载约束配置。
+
+    ============================================================================
+    业务场景 (什么情况下会调用这个函数)
+    ============================================================================
+    - 场景1: 项目启动时加载所有约束
+      系统启动时需要批量加载项目中所有的约束配置文件。
+
+    - 场景2: 批量导入约束
+      用户可以一次性导入多个约束配置文件。
+
+    ============================================================================
+    数据流 (输入如何变成输出)
+    ============================================================================
+    输入参数:
+      - constraint_paths: list，constraint 文件路径列表
+        示例值: [
+            "constraints/unique_email.constraint.yaml",
+            "constraints/gender_allowed.constraint.yaml"
+        ]
+
+    处理步骤:
+      遍历路径列表，依次调用 load_constraint 加载每个约束
+
+    最终输出: Dict[str, ConstraintFile]，约束 ID -> ConstraintFile 映射
+      示例:
+        constraints = load_constraints(paths)
+        print(constraints.keys())  # dict_keys(['unique_email', 'gender_allowed'])
+
+    ============================================================================
+    异常处理
+    ============================================================================
+    | 异常类型 | 触发条件 | 处理方式 |
+    |---------|---------|---------|
+    | ValueError | 单个文件加载失败 | 停止并抛出异常 |
+
+    :param constraint_paths: constraint 文件路径列表，每个元素为文件路径
+    :return: 约束配置字典，键为 constraint.id（约束ID），值为 ConstraintFile 对象
+    :raises ValueError: 任一文件加载或验证失败时抛出
+    """
+    # 初始化结果字典，使用 constraint_id 作为键便于后续快速查找
+    constraints: dict[str, ConstraintFile] = {}
+    # 遍历所有文件路径，依次加载每个约束配置
+    for path in constraint_paths:
+        # 加载单个约束配置（包含验证）
+        constraint = load_constraint(path)
+        # 以约束ID为键存储，支持快速通过ID获取约束配置
+        constraints[constraint.id] = constraint
+    return constraints

app/shared/core/project/constraint/registry.py

@@ -0,0 +1,233 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 约束类型注册表模块
+
+功能概述:
+- 提供约束类型名称到约束类的映射
+- 支持约束类型别名（多种命名风格标准化）
+- 提供参数过滤功能（根据类构造函数签名过滤参数）
+- 提供支持的约束类型列表（供 API/前端发现使用）
+
+架构设计:
+- 注册中心模式: 使用字典维护约束类型与实现类的映射关系
+- 名称标准化: 支持标准命名、下划线命名、驼峰命名等多种风格
+- 参数过滤: 使用 inspect 模块获取类构造函数签名并过滤参数
+
+重要约定:
+- 为避免 core 层反向依赖 domain 层，本模块只保存约束类的导入路径字符串。
+- 真正的约束类通过 resolve_constraint_class() 在运行时延迟解析，由 services 层使用。
+"""
+
+from __future__ import annotations
+
+# inspect 模块用于获取类构造函数的签名，实现参数过滤
+import importlib
+import inspect
+from typing import Any
+
+# ============================================================
+# 约束类型注册表
+# ============================================================
+# 键：约束类型标准名称（首字母大写）
+# 值：约束类在项目中的完整导入路径（字符串）
+# 用于在 factory.py 中根据类型名称延迟解析对应的约束类
+#
+# 注意：此处不使用直接类引用，以保证 core 层不依赖 domain 层。
+
+CONSTRAINT_REGISTRY: dict[str, str] = {
+    # 唯一约束：支持单列或多列组合唯一
+    "Unique": "app.shared.domain.validation_constraints.UniqueConstraint",
+    # 非空约束：列值不能为空
+    "NotNull": "app.shared.domain.validation_constraints.NotNullConstraint",
+    # 允许值约束：列值必须来自预定义集合
+    "AllowedValues": "app.shared.domain.validation_constraints.AllowedValuesConstraint",
+    # 外键约束：参照完整性校验
+    "ForeignKey": "app.shared.domain.validation_constraints.ForeignKeyConstraints",
+    # 区间约束：数值/日期范围校验
+    "Range": "app.shared.domain.validation_constraints.RangeConstraint",
+    # 条件约束：满足 IF 条件时执行 THEN 规则
+    "Conditional": "app.shared.domain.validation_constraints.ConditionalConstraint",
+    # 脚本约束：执行自定义表达式
+    "Scripted": "app.shared.domain.validation_constraints.ScriptedConstraint",
+    # 字符集约束：校验 ASCII 或中文字符
+    "Charset": "app.shared.domain.validation_constraints.CharsetConstraint",
+    # 日期逻辑约束：日期比较和计算
+    "DateLogic": "app.shared.domain.validation_constraints.DateLogicConstraint",
+    # 复合约束：包含多个子约束，按逻辑策略聚合结果
+    "Composite": "app.shared.domain.validation_constraints.CompositeConstraint",
+}
+
+
+# ============================================================
+# 约束类型别名映射表
+# ============================================================
+# 键：各种命名风格的类型名称
+# 值：标准名称（首字母大写）
+# 用于支持用户使用不同格式的类型名称
+
+CONSTRAINT_TYPE_ALIASES: dict[str, str] = {
+    # 唯一约束别名
+    "unique": "Unique",
+    # 非空约束别名（多种拼写）
+    "not_null": "NotNull",
+    "notnull": "NotNull",
+    # 允许值约束别名
+    "allowed_values": "AllowedValues",
+    "allowedvalues": "AllowedValues",
+    # 外键约束别名
+    "foreign_key": "ForeignKey",
+    "foreignkey": "ForeignKey",
+    # 区间约束别名
+    "range": "Range",
+    # 条件约束别名
+    "conditional": "Conditional",
+    # 脚本约束别名
+    "scripted": "Scripted",
+    # 日期逻辑约束别名
+    "datelogic": "DateLogic",
+    "date_logic": "DateLogic",
+}
+
+
+def normalize_constraint_type(type_name: str) -> str:
+    """
+    @methoddesc 规范化约束类型名称。
+
+    将各种命名风格的类型名称转换为标准名称（首字母大写）。
+    查找顺序：
+    1. 直接匹配（标准名称）
+    2. 精确匹配别名
+    3. 小写匹配别名
+
+    :param type_name: 约束类型名称（如 "unique"、"Unique"、"not_null" 等）
+    :return: 规范化后的标准名称（如 "Unique"、"NotNull" 等）
+    """
+    # 步骤1：检查是否是标准名称（已在注册表中）
+    if type_name in CONSTRAINT_REGISTRY:
+        return type_name
+
+    # 步骤2：去除首尾空格后精确匹配别名
+    key = (type_name or "").strip()
+    if key in CONSTRAINT_TYPE_ALIASES:
+        return CONSTRAINT_TYPE_ALIASES[key]
+
+    # 步骤3：小写匹配（支持混合大小写输入）
+    lower = key.lower()
+    return CONSTRAINT_TYPE_ALIASES.get(lower, key)
+
+
+def resolve_constraint_class(type_name: str) -> type | None:
+    """@methoddesc 根据标准约束类型名称延迟解析对应的 domain 约束类。
+
+    通过保存的导入路径字符串动态导入类，避免 core 层在导入时依赖 domain 层。
+
+    :param type_name: 标准约束类型名称（如 "Unique"）
+    :return: 对应的约束类；如果未注册则返回 None
+
+    示例：
+        >>> cls = resolve_constraint_class("Unique")
+        >>> cls.__name__
+        'UniqueConstraint'
+    """
+    path = CONSTRAINT_REGISTRY.get(type_name)
+    if not path:
+        return None
+    module_path, class_name = path.rsplit(".", 1)
+    module = importlib.import_module(module_path)
+    cls = getattr(module, class_name)
+    if isinstance(cls, type):
+        return cls
+    return None
+
+
+def filter_kwargs_for_class(cls: type[Any], kwargs: dict[str, Any]) -> dict[str, Any]:
+    """
+    @methoddesc 按类构造函数签名过滤参数。
+
+    使用 inspect 模块获取类的 __init__ 方法签名，
+    只保留kwargs中与构造函数参数名匹配的键值对。
+    这确保了传入的参数不会因为类不接受而导致错误。
+
+    :param cls: 目标类（通常是约束实现类）
+    :param kwargs: 参数字典（可能包含类不接受的键）
+    :return: 过滤后的参数字典（只包含类接受的键）
+
+    示例：
+        class MyConstraint:
+            def __init__(self, table: str, column: str):
+                ...
+
+        kwargs = {"table": "users", "column": "email", "extra": "ignored"}
+        result = filter_kwargs_for_class(MyConstraint, kwargs)
+        # result = {"table": "users", "column": "email"}
+        # "extra" 被过滤掉
+    """
+    # 获取类的构造函数签名
+    sig = inspect.signature(cls)
+
+    # 提取构造函数接受的参数名集合
+    allowed = set(sig.parameters.keys())
+
+    # 移除 "self" 参数（不属于构造函数参数）
+    allowed.discard("self")
+
+    # 过滤 kwargs，只保留允许的参数
+    # 使用字典推导式进行过滤
+    return {k: v for k, v in kwargs.items() if k in allowed}
+
+
+def get_supported_constraint_types() -> dict[str, str]:
+    """
+    @methoddesc 获取当前支持的约束类型及其说明。
+
+    返回一个字典，键为约束类型名称，值为简要说明。
+    供 API 端点和前端使用，用于：
+    - 约束类型下拉列表
+    - 约束类型文档展示
+    - 约束类型发现和验证
+
+    :return: 约束类型与说明的字典
+
+    返回值示例：
+        {
+            "Unique": "唯一约束：支持单列或多列组合",
+            "NotNull": "非空约束：列值不能为空",
+            ...
+        }
+    """
+    return {
+        # 唯一约束：支持单列或多列组合
+        "Unique": "唯一约束：支持单列或多列组合",
+        # 非空约束：列值不能为空
+        "NotNull": "非空约束：列值不能为空",
+        # 允许值约束：列值必须来自集合
+        "AllowedValues": "允许值约束：列值必须来自集合",
+        # 外键约束：参照完整性校验
+        "ForeignKey": "外键约束：参照完整性校验",
+        # 条件约束：满足 IF 条件时 THEN 必须满足规则
+        "Conditional": "条件约束：满足 IF 条件时 THEN 必须满足规则",
+        # 脚本约束：逐行执行表达式（需要 allow_unsafe_eval）
+        "Scripted": "脚本约束：逐行执行表达式（需要 allow_unsafe_eval）",
+        # 字符集约束：校验 ASCII 或中文字符
+        "Charset": "字符集约束：校验ASCII或中文字符",
+        # 日期逻辑约束：日期比较和计算
+        "DateLogic": "日期逻辑约束：日期比较和计算",
+        # 区间约束：数值必须在指定范围内
+        "Range": "区间约束：数值必须在指定范围内",
+        # 组合约束：多个子约束AND/OR组合
+        "Composite": "组合约束：多个子约束AND/OR组合",
+    }

app/shared/core/project/constraint/types/__init__.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 约束类型统一导出模块
+
+功能概述:
+- 集中导出所有约束相关的数据类型
+- 统一 ConstraintFile、ConstraintFileV2 和各约束 refs 类型
+- 简化外部模块的导入路径
+
+架构设计:
+- 聚合导出：从 constraint_file.py 和 refs.py 收集类型
+- __all__ 显式控制：明确对外暴露的符号列表
+
+输入示例:
+    from app.shared.core.project.constraint.types import ConstraintFileV2, UniqueRefs
+
+输出示例:
+    可直接使用导入的类型构建约束配置
+"""
+
+from .constraint_file import ConstraintFile, ConstraintFileV2, ConstraintType
+from .refs import (
+    AllowedValuesRefs,
+    CharsetRefs,
+    ConditionalIfCondition,
+    ConditionalRefs,
+    DateLogicRefs,
+    ForeignKeyRefs,
+    NotNullRefs,
+    RangeRefs,
+    ScriptedRefs,
+    UniqueRefs,
+)
+
+__all__ = [
+    "ConstraintFile",
+    "ConstraintFileV2",
+    "ConstraintType",
+    "AllowedValuesRefs",
+    "CharsetRefs",
+    "ConditionalIfCondition",
+    "ConditionalRefs",
+    "DateLogicRefs",
+    "ForeignKeyRefs",
+    "NotNullRefs",
+    "RangeRefs",
+    "ScriptedRefs",
+    "UniqueRefs",
+]