@cloudbase/cals 1.2.17 → 1.2.18-alpha.0

package/lib/cjs/utils/mermaid-datasource/mermaid-json-transform.js

@@ -0,0 +1,624 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToMermaid = exports.mermaidToJsonSchema = exports.parseMermaid = void 0;
+const classDiagram_js_1 = require("./classDiagram.js");
+const parserInstance = classDiagram_js_1.parser;
+const classDb_js_1 = __importDefault(require("./classDb.js"));
+// const code = 'classDiagram\n    class User {\n        id: string <<用户ID>>\n        name: string <<姓名>>\n        phone: phone <<手机号>>\n        email: email <<邮箱>>\n        avatar: x-image <<头像>>\n        required() ["name", "phone"]\n        unique() ["phone", "email"]\n    }\n    \n    class Activity {\n        id: string <<活动ID>>\n        title: string <<活动标题>>\n        description: x-rtf <<活动详情>>\n        coverImage: x-image <<封面图>>\n        startTime: datetime <<开始时间>>\n        endTime: datetime <<结束时间>>\n        address: string <<活动地址>>\n        location: x-location <<地理位置>>\n        maxParticipants: number = 100 <<最大参与人数>>\n        status: x-enum = ["未开始", "进行中", "已结束", "已取消"] <<状态>>\n        required() ["title", "startTime", "endTime"]\n    }\n    \n    class Reservation {\n        id: string <<预约ID>>\n        userId: string <<用户ID>>\n        activityId: string <<活动ID>>\n        reservationTime: datetime <<预约时间>>\n        status: x-enum = ["待确认", "已预约", "已取消", "已签到"] <<状态>>\n        notes: string <<备注>>\n        required() ["userId", "activityId", "reservationTime"]\n    }\n    \n    class ActivityCategory {\n        id: string <<分类ID>>\n        name: string <<分类名称>>\n        icon: x-image <<图标>>\n        required() ["name"]\n    }\n    \n    class Review {\n        id: string <<评价ID>>\n        userId: string <<用户ID>>\n        activityId: string <<活动ID>>\n        rating: number = 5 <<评分>>\n        comment: string <<评价内容>>\n        reviewTime: datetime <<评价时间>>\n        required() ["userId", "activityId", "rating"]\n    }\n    User "1" --> "n" Reservation : userId\n    Activity "1" --> "n" Reservation : activityId\n    Activity "n" --> "1" ActivityCategory : categoryId\n    User "1" --> "n" Review : userId\n    Activity "1" --> "n" Review : activityId\n    note for User "用户模型"\n    note for Activity "活动模型"\n    note for Reservation "预约模型"\n    note for ActivityCategory "活动分类模型"\n    note for Review "评价模型"\n\n';
+// 检查类型是否为关联关系类型（其他类名或其他类名的数组）
+function isRelationshipType(type, classNames) {
+    // 移除数组标记
+    const baseType = type.endsWith('[]') ? type.slice(0, -2) : type;
+    // 检查是否为已知的类名
+    return classNames.includes(baseType);
+}
+function convertToJSONSchema(data) {
+    const schemas = {};
+    // 解析关联关系，建立关系映射 - 用于查找关联信息
+    const relationMap = {};
+    // 处理关联关系
+    if (data.relations) {
+        data.relations.forEach((relation) => {
+            const { id1, id2, relation: rel, relationTitle1, relationTitle2, title } = relation;
+            // 判断关系方向和类型
+            const hasType1 = rel.type1 !== undefined && rel.type1 !== 'none';
+            const hasType2 = rel.type2 !== undefined && rel.type2 !== 'none';
+            if (!relationMap[id1])
+                relationMap[id1] = {};
+            if (!relationMap[id2])
+                relationMap[id2] = {};
+            if (hasType2) {
+                // id1 -> id2 的关系
+                relationMap[id1][title || ''] = {
+                    targetClass: id2,
+                    cardinality1: relationTitle1 || '',
+                    cardinality2: relationTitle2 || '',
+                    isReverse: false,
+                };
+            }
+            if (hasType1) {
+                // id2 -> id1 的关系（反向）
+                relationMap[id2][title || ''] = {
+                    targetClass: id1,
+                    cardinality1: relationTitle2 || '',
+                    cardinality2: relationTitle1 || '',
+                    isReverse: true,
+                };
+            }
+        });
+    }
+    // TODO: 拼反向关联关系
+    // Object.entries(relationMap).forEach(([className, relations]) => {
+    //     Object.entries(relations).forEach(([fieldName, relation]) => {
+    //         const { targetClass, cardinality1, cardinality2 } = relation;
+    //         if ((cardinality1 === '1' && cardinality2 === 'n') || (cardinality1 === 'n' && cardinality2 === '1')) {
+    //             const targetReleation = relationMap[relationMap[className][fieldName].targetClass];
+    //             const reverseRelation = Object.entries(targetReleation ?? {}).find(([_, relation]) => relation.targetClass === className);
+    //             if (!reverseRelation) {
+    //                 let reverseFieldName;
+    //                 const match = fieldName.match(/(\w+)2(\w+)/);
+    //                 if (match) {
+    //                     const [_, field1, field2] = match;
+    //                     reverseFieldName = `${field2}2${field1}`;
+    //                 } else {
+    //                     if (cardinality1 === 'n') {
+    //                         reverseFieldName = pluralize.plural(className.toLowerCase());
+    //                     } else {
+    //                         reverseFieldName = className.toLowerCase();
+    //                     }
+    //                 }
+    //                 relationMap[targetClass][reverseFieldName] = {
+    //                     targetClass: className,
+    //                     cardinality1: cardinality2,
+    //                     cardinality2: cardinality1,
+    //                     isReverse: true
+    //                 };
+    //             }
+    //         }
+    //     });
+    // })
+    // 为每个类生成JSON Schema
+    Object.entries(data.classes).forEach(([className, classInfo]) => {
+        var _a, _b;
+        // 查找该类的注释作为标题
+        const noteText = ((_b = (_a = data.notes) === null || _a === void 0 ? void 0 : _a.find((note) => note.class === className)) === null || _b === void 0 ? void 0 : _b.text) || '';
+        const schema = {
+            type: 'object',
+            title: noteText || classInfo.label || className,
+            description: noteText || classInfo.label || className,
+            properties: {},
+            required: [],
+        };
+        // 处理成员属性（包括关联字段）
+        if (classInfo.members) {
+            classInfo.members.forEach((member) => {
+                var _a;
+                const memberName = member.name;
+                const parsed = parseMemberDefinition(memberName);
+                if (parsed) {
+                    // 检查是否为关联关系字段
+                    const isRelationField = isRelationshipType(parsed.type, Object.keys(data.classes));
+                    if (isRelationField) {
+                        // 处理关联字段
+                        const baseType = parsed.type.endsWith('[]') ? parsed.type.slice(0, -2) : parsed.type;
+                        const isArray = parsed.type.endsWith('[]');
+                        // 查找关联关系信息
+                        const relationInfo = (_a = relationMap[className]) === null || _a === void 0 ? void 0 : _a[parsed.name];
+                        let format = 'one-one'; // 默认格式
+                        if (relationInfo) {
+                            format = determineRelationType(relationInfo.cardinality1, relationInfo.cardinality2, relationInfo.isReverse).format;
+                        }
+                        else {
+                            // 根据类型推断格式
+                            format = isArray ? 'one-many' : 'one-one';
+                        }
+                        const parentFieldKey = `_${className.toLowerCase()}`;
+                        schema.properties[parsed.name] = {
+                            type: isArray ? 'array' : 'object',
+                            format: format,
+                            title: parsed.title,
+                            description: parsed.title,
+                            'x-parent': {
+                                parentDataSourceName: baseType,
+                                parentFieldKey,
+                                parentFieldTitle: `关联到${baseType} ${format}`,
+                            },
+                            'x-deleteWay': 'doNothing',
+                        };
+                        if (isArray) {
+                            schema.properties[parsed.name].items = {
+                                type: 'object',
+                                properties: {
+                                    _id: { name: '_id', title: '数据标识', type: 'string' },
+                                },
+                            };
+                        }
+                        else {
+                            schema.properties[parsed.name].properties = {
+                                _id: { name: '_id', title: '数据标识', type: 'string' },
+                            };
+                        }
+                    }
+                    else {
+                        // 处理普通字段
+                        schema.properties[parsed.name] = {
+                            type: mapType(parsed.type),
+                            title: parsed.title,
+                            description: parsed.title,
+                        };
+                        // 处理默认值
+                        if (parsed.defaultValue !== undefined) {
+                            schema.properties[parsed.name].default = parsed.defaultValue;
+                        }
+                        // 处理枚举类型
+                        if (parsed.type.startsWith('x-enum')) {
+                            schema.properties[parsed.name].type = 'string';
+                            schema.properties[parsed.name].format = 'enum';
+                            if (parsed.enumValues) {
+                                schema.properties[parsed.name].enum = parsed.enumValues;
+                            }
+                        }
+                        // 处理数组类型
+                        if (parsed.type.endsWith('[]')) {
+                            const baseType = parsed.type.slice(0, -2);
+                            schema.properties[parsed.name] = {
+                                type: 'array',
+                                title: parsed.title,
+                                description: parsed.title,
+                                items: {
+                                    type: mapType(baseType),
+                                },
+                            };
+                        }
+                        // 处理特殊格式
+                        const format = getSpecialFormat(parsed.type);
+                        if (format) {
+                            schema.properties[parsed.name].format = format;
+                        }
+                    }
+                }
+            });
+        }
+        // 处理方法中的约束
+        if (classInfo.methods) {
+            classInfo.methods.forEach((method) => {
+                const methodName = method.name;
+                if (methodName.startsWith('required()')) {
+                    const fields = extractArrayFromMethod(methodName);
+                    if (fields.length > 0) {
+                        schema.required = fields;
+                        for (const field of fields) {
+                            safeSet(schema.properties[field], ['x-required'], true);
+                        }
+                    }
+                }
+                else if (methodName.startsWith('unique()')) {
+                    const fields = extractArrayFromMethod(methodName);
+                    for (const field of fields) {
+                        safeSet(schema.properties[field], ['x-unique'], true);
+                    }
+                }
+                else if (methodName.startsWith('display_field()')) {
+                    const fieldName = extractDisplayField(methodName);
+                    if (fieldName) {
+                        schema['x-primary-column'] = fieldName;
+                    }
+                }
+                else if (methodName.startsWith('enum_')) {
+                    const fieldName = methodName.split('(')[0].replace('enum_', '');
+                    const enumValues = extractArrayFromMethod(methodName);
+                    if (schema.properties[fieldName]) {
+                        schema.properties[fieldName].enum = enumValues;
+                    }
+                }
+            });
+        }
+        // 根据关联关系图添加缺失的关联字段
+        const classRelations = relationMap[className] || {};
+        Object.entries(classRelations).forEach(([relationName, relationInfo]) => {
+            const { targetClass, cardinality1, cardinality2, isReverse } = relationInfo;
+            const relationType = determineRelationType(cardinality1, cardinality2, isReverse);
+            // 如果该字段已存在但不是关联字段，则转换为关联字段
+            if (schema.properties[relationName] && !schema.properties[relationName].format) {
+                // 保留原有的标题
+                const originalTitle = schema.properties[relationName].title;
+                const parentFieldKey = `_${className.toLowerCase()}`;
+                schema.properties[relationName] = {
+                    type: relationType.type,
+                    format: relationType.format,
+                    title: originalTitle,
+                    description: originalTitle,
+                    'x-parent': {
+                        parentDataSourceName: targetClass,
+                        parentFieldKey,
+                        parentFieldTitle: `关联到${targetClass} ${relationType.format}`,
+                    },
+                    'x-deleteWay': 'doNothing',
+                };
+                if (relationType.type === 'array') {
+                    schema.properties[relationName].items = {
+                        type: 'object',
+                        properties: {
+                            _id: { name: '_id', title: '数据标识', type: 'string' },
+                        },
+                    };
+                }
+                else {
+                    schema.properties[relationName].properties = {
+                        _id: { name: '_id', title: '数据标识', type: 'string' },
+                    };
+                }
+            }
+            // 如果该字段不存在，则添加
+            else if (!schema.properties[relationName]) {
+                const targetRelations = relationMap[relationMap[className][relationName].targetClass];
+                // const reverseField = Object.keys(targetRelations).find((k) => {
+                //     return targetRelations[k].targetClass === className;
+                // });
+                const reverseField = `_${className.toLowerCase()}`;
+                schema.properties[relationName] = {
+                    type: relationType.type,
+                    format: relationType.format,
+                    title: `关联到${targetClass}`,
+                    description: `与${targetClass}的关联关系`,
+                    'x-parent': {
+                        parentDataSourceName: targetClass,
+                        parentFieldKey: reverseField,
+                        parentFieldTitle: `关联到${targetClass} ${relationType.format}`,
+                    },
+                    'x-deleteWay': 'doNothing',
+                };
+                if (relationType.type === 'array') {
+                    schema.properties[relationName].items = {
+                        type: 'object',
+                        properties: {
+                            _id: { name: '_id', title: '数据标识', type: 'string' },
+                        },
+                    };
+                }
+                else {
+                    schema.properties[relationName].properties = {
+                        _id: { name: '_id', title: '数据标识', type: 'string' },
+                    };
+                }
+            }
+        });
+        schemas[className] = schema;
+    });
+    return schemas;
+}
+// 解析成员定义
+function parseMemberDefinition(memberDef) {
+    // 解析格式：name: type = defaultValue <<title>>
+    const regex = /^(\w+):\s*([^=<]+?)(?:\s*=\s*([^<]+?))?(?:\s*<<(.+?)>>)?$/;
+    const match = memberDef.match(regex);
+    if (!match)
+        return null;
+    const [, name, type, defaultValue, title] = match;
+    let enumValues = null;
+    let cleanType = type.trim();
+    // 处理枚举类型
+    if (cleanType.includes('=')) {
+        const enumMatch = cleanType.match(/x-enum\s*=\s*\[(.*?)\]/);
+        if (enumMatch) {
+            enumValues = enumMatch[1].split(',').map((v) => v.trim().replace(/"/g, ''));
+            cleanType = 'x-enum';
+        }
+    }
+    return {
+        name: name.trim(),
+        type: cleanType,
+        defaultValue: defaultValue ? parseDefaultValue(defaultValue.trim()) : undefined,
+        title: (title === null || title === void 0 ? void 0 : title.trim()) || name.trim(),
+        enumValues,
+    };
+}
+// 映射类型
+function mapType(type) {
+    const typeMap = {
+        string: 'string',
+        number: 'number',
+        boolean: 'boolean',
+        datetime: 'number',
+        email: 'string',
+        phone: 'string',
+        'x-enum': 'string',
+        'x-image': 'string',
+        'x-rtf': 'string',
+        'x-location': 'object',
+    };
+    return typeMap[type] || 'string';
+}
+// 获取特殊格式
+function getSpecialFormat(type) {
+    const formatMap = {
+        datetime: 'datetime',
+        email: 'email',
+        phone: 'phone',
+        'x-image': 'x-image',
+        'x-rtf': 'x-rtf',
+        'x-location': 'x-location',
+        'x-area-code': 'x-area-code',
+        'x-file': 'x-file',
+    };
+    // 只保留这些
+    return formatMap[type] || null;
+}
+// 解析默认值
+function parseDefaultValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^\d+$/.test(value))
+        return parseInt(value);
+    if (/^\d+\.\d+$/.test(value))
+        return parseFloat(value);
+    if (value.startsWith('[') && value.endsWith(']')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (_a) {
+            return value;
+        }
+    }
+    return value.replace(/"/g, '');
+}
+// 从方法字符串中提取数组
+function extractArrayFromMethod(methodStr) {
+    const match = methodStr.match(/\[(.*?)\]/);
+    if (!match)
+        return [];
+    return match[1].split(',').map((item) => item.trim().replace(/"/g, ''));
+}
+// 从方法字符串中提取显示字段
+function extractDisplayField(methodStr) {
+    const match = methodStr.match(/display_field\(\)\s*"([^"]+)"/);
+    if (!match)
+        return null;
+    return match[1].trim();
+}
+// 确定关系类型
+function determineRelationType(cardinality1, cardinality2, isReverse) {
+    const is1ToMany = cardinality1 === '1' && (cardinality2 === 'n' || cardinality2 === 'm');
+    const isManyTo1 = (cardinality1 === 'n' || cardinality1 === 'm') && cardinality2 === '1';
+    const is1To1 = cardinality1 === '1' && cardinality2 === '1';
+    const isManyToMany = (cardinality1 === 'n' || cardinality1 === 'm') && (cardinality2 === 'n' || cardinality2 === 'm');
+    if (isManyToMany) {
+        return { type: 'array', format: 'many-many' };
+    }
+    else if (is1ToMany) {
+        return { type: 'array', format: 'one-many' };
+    }
+    else if (isManyTo1) {
+        return { type: 'object', format: 'many-one' };
+    }
+    else if (is1To1) {
+        return { type: 'object', format: isReverse ? 'one-one-r' : 'one-one' };
+    }
+    return { type: 'object', format: 'one-one' };
+}
+function safeSet(obj, path, value) {
+    let current = obj;
+    if (typeof current !== 'object' || current === null) {
+        throw new TypeError(`Expected object, got ${typeof current}`);
+    }
+    for (let i = 0; i < path.length; i++) {
+        const key = path[i];
+        if (typeof current[key] !== 'object' || current[key] === null) {
+            if (i === path.length - 1) {
+                current[key] = value;
+            }
+            else {
+                current[key] = {};
+            }
+        }
+        current = current[key];
+    }
+    return obj;
+}
+function parseMermaid(code) {
+    const classDb = new classDb_js_1.default();
+    parserInstance.yy = classDb;
+    parserInstance.parse(code);
+    return classDb.exportData();
+}
+exports.parseMermaid = parseMermaid;
+function mermaidToJsonSchema(code) {
+    const classDb = new classDb_js_1.default();
+    parserInstance.yy = classDb;
+    parserInstance.parse(code);
+    const exportedData = classDb.exportData();
+    const schemas = convertToJSONSchema(exportedData);
+    return schemas;
+}
+exports.mermaidToJsonSchema = mermaidToJsonSchema;
+// 反向转换：将JSON Schema转换为Mermaid类图
+function jsonSchemaToMermaid(schemas) {
+    const lines = [];
+    lines.push('classDiagram');
+    // 存储关联关系，稍后处理
+    const relationSet = new Set();
+    const notes = [];
+    // 为每个类生成定义
+    Object.entries(schemas).forEach(([className, schema]) => {
+        lines.push(`    class ${className} {`);
+        const properties = schema.properties || {};
+        const required = schema.required || [];
+        const uniqueFields = [];
+        const enumFields = {};
+        // 处理普通属性和关联关系
+        Object.entries(properties).forEach(([propName, prop]) => {
+            var _a;
+            // 检查是否为关联关系字段（基于format属性）
+            const isRelationField = prop.format && ['one-one', 'one-one-r', 'one-many', 'many-one', 'many-many'].includes(prop.format);
+            if (isRelationField) {
+                // 只收集关联关系用于后续生成，不添加到类定义中
+                const targetClass = ((_a = prop['x-parent']) === null || _a === void 0 ? void 0 : _a.parentDataSourceName) || '';
+                if (targetClass && prop.format) {
+                    const relation = generateRelation(className, targetClass, propName, prop.format);
+                    if (relation) {
+                        relationSet.add(relation);
+                    }
+                }
+                return;
+            }
+            // 生成普通属性定义
+            let propLine = `        ${propName}: `;
+            // 确定类型
+            let propType = prop.type;
+            if (prop.format) {
+                switch (prop.format) {
+                    case 'email':
+                        propType = 'email';
+                        break;
+                    case 'phone':
+                        propType = 'phone';
+                        break;
+                    case 'datetime':
+                        propType = 'datetime';
+                        break;
+                    case 'enum':
+                        propType = 'x-enum';
+                        if (prop.enum) {
+                            enumFields[propName] = prop.enum;
+                        }
+                        break;
+                    case 'x-image':
+                        propType = 'x-image';
+                        break;
+                    case 'x-rtf':
+                        propType = 'x-rtf';
+                        break;
+                    case 'x-location':
+                        propType = 'x-location';
+                        break;
+                    case 'x-area-code':
+                        propType = 'x-area-code';
+                        break;
+                    case 'x-file':
+                        propType = 'x-file';
+                        break;
+                }
+            }
+            else {
+                // 如果没有format，根据type来决定
+                switch (prop.type) {
+                    case 'number':
+                        propType = 'number';
+                        break;
+                    case 'boolean':
+                        propType = 'boolean';
+                        break;
+                    case 'string':
+                    default:
+                        propType = 'string';
+                        break;
+                }
+            }
+            // 处理数组类型
+            if (prop.type === 'array' && prop.items) {
+                const itemType = prop.items.type;
+                propType = `${itemType}[]`;
+            }
+            propLine += propType;
+            // 添加默认值
+            if (prop.default !== undefined) {
+                if (typeof prop.default === 'string') {
+                    propLine += ` = "${prop.default}"`;
+                }
+                else {
+                    propLine += ` = ${prop.default}`;
+                }
+            }
+            // 添加标题
+            if (prop.title) {
+                propLine += ` <<${prop.title}>>`;
+            }
+            lines.push(propLine);
+            // 收集唯一性约束
+            if (prop['x-unique']) {
+                uniqueFields.push(propName);
+            }
+        });
+        // 添加约束方法
+        if (required.length > 0) {
+            const requiredStr = required.map((f) => `"${f}"`).join(', ');
+            lines.push(`        required() [${requiredStr}]`);
+        }
+        if (uniqueFields.length > 0) {
+            const uniqueStr = uniqueFields.map((f) => `"${f}"`).join(', ');
+            lines.push(`        unique() [${uniqueStr}]`);
+        }
+        // 添加显示字段方法
+        if (schema['x-primary-column']) {
+            lines.push(`        display_field() "${schema['x-primary-column']}"`);
+        }
+        // 添加枚举方法
+        Object.entries(enumFields).forEach(([fieldName, values]) => {
+            const enumStr = values.map((v) => `"${v}"`).join(', ');
+            lines.push(`        enum_${fieldName}() [${enumStr}]`);
+        });
+        lines.push('    }');
+        lines.push('');
+        // 收集注释
+        if (schema.title && schema.title !== className) {
+            notes.push(`    note for ${className} "${schema.title}"`);
+        }
+    });
+    // 添加关联关系（去重后）
+    if (relationSet.size > 0) {
+        lines.push('    %% 关联关系');
+        // 去重逻辑：只保留原始方向的关系，避免重复
+        const uniqueRelations = new Set();
+        const processedPairs = new Set();
+        Array.from(relationSet).forEach((relationStr) => {
+            const match = relationStr.match(/(\w+)\s+"([^"]+)"\s+(.*?)\s+"([^"]+)"\s+(\w+)\s*:\s*(.+)/);
+            if (match) {
+                const [, class1, card1, arrow, card2, class2, relationName] = match;
+                // 创建关系对的标识符 - 考虑箭头方向
+                const directionKey = arrow.includes('<--') ? `${class2}-${class1}` : `${class1}-${class2}`;
+                const pairKey = directionKey + '-' + relationName;
+                // 如果这个关系对还没有被处理过，就添加它
+                if (!processedPairs.has(pairKey)) {
+                    uniqueRelations.add(relationStr);
+                    processedPairs.add(pairKey);
+                }
+            }
+        });
+        Array.from(uniqueRelations).forEach((relation) => {
+            lines.push(`    ${relation}`);
+        });
+        lines.push('');
+    }
+    // 添加注释
+    if (notes.length > 0) {
+        lines.push('    %% 类的命名');
+        notes.forEach((note) => {
+            lines.push(note);
+        });
+    }
+    return lines.join('\n');
+}
+exports.jsonSchemaToMermaid = jsonSchemaToMermaid;
+// 生成关联关系字符串
+function generateRelation(fromClass, toClass, relationName, format) {
+    const relationMap = {
+        'one-one': { cardinality1: '1', cardinality2: '1', arrow: '-->' },
+        'one-one-r': { cardinality1: '1', cardinality2: '1', arrow: '<--' },
+        'one-many': { cardinality1: '1', cardinality2: 'n', arrow: '-->' },
+        'many-one': { cardinality1: 'n', cardinality2: '1', arrow: '-->' },
+        'many-many': { cardinality1: 'n', cardinality2: 'm', arrow: '-->' },
+    };
+    const relation = relationMap[format];
+    if (!relation)
+        return null;
+    // 对于反向关系，需要交换类的位置
+    if (format === 'one-one-r') {
+        return `${toClass} "${relation.cardinality2}" ${relation.arrow} "${relation.cardinality1}" ${fromClass} : ${relationName}`;
+    }
+    return `${fromClass} "${relation.cardinality1}" ${relation.arrow} "${relation.cardinality2}" ${toClass} : ${relationName}`;
+}

package/lib/cjs/utils/mermaid-datasource/prompts/cases/activity_reservation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 本文件由 build.ts 自动生成，请勿手动修改
+ * }
+ */
+declare const _default: {
+    user: string;
+    assistant: string;
+    name: string;
+};
+export default _default;
+//# sourceMappingURL=activity_reservation.d.ts.map

package/lib/cjs/utils/mermaid-datasource/prompts/cases/activity_reservation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity_reservation.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/mermaid-datasource/prompts/cases/activity_reservation.ts"],"names":[],"mappings":"AAGA;;;GAGG;;;;;;AAGH,wBAAurF"}

package/lib/cjs/utils/mermaid-datasource/prompts/cases/activity_reservation.js

@@ -0,0 +1,9 @@
+"use strict";
+/* eslint-disable */
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 本文件由 build.ts 自动生成，请勿手动修改
+ * }
+ */
+exports.default = { "user": "创建一个活动预约管理应用", "assistant": "以下是基于活动预约管理应用的Mermaid类图设计：\n```mermaid\nclassDiagram\n    class Activity {\n        title: string <<活动标题>>\n        description: x-rtf <<活动描述>>\n        coverImage: x-image <<封面图片>>\n        startTime: datetime <<开始时间>>\n        endTime: datetime <<结束时间>>\n        registrationDeadline: datetime <<报名截止时间>>\n        maxParticipants: number <<最大参与人数>>\n        currentParticipants: number = 0 <<当前参与人数>>\n        location: string <<活动地点>>\n        areaCode: x-area-code <<活动区域>>\n        status: x-enum = \"未开始\" <<活动状态>>\n        required() [\"title\", \"startTime\", \"endTime\", \"maxParticipants\"]\n        enum_status() [\"未开始\", \"进行中\", \"已结束\", \"已取消\"] \n        unique() [\"title\"]\n    }\n    \n    class ReservationSystemUser {\n        username: string <<用户名>>\n        email: email <<邮箱>>\n        phone: phone <<手机号>>\n        avatar: x-image <<头像>>\n        registrationTime: datetime <<注册时间>>\n        lastLoginTime: datetime <<最后登录时间>>\n        required() [\"username\", \"email\"]\n        unique() [\"username\", \"email\", \"phone\"]\n    }\n    \n    class ActivityReservation {\n        reservationTime: datetime <<预约时间>>\n        status: x-enum = \"待确认\" <<预约状态>>\n        notes: string <<备注>>\n        enum_status() [\"待确认\", \"已确认\", \"已取消\", \"已签到\"]\n        required() [\"reservationTime\"]\n    }\n    \n    class ActivityCategory {\n        name: string <<分类名称>>\n        icon: string <<图标>>\n        required() [\"name\"]\n        unique() [\"name\"]\n    }\n    \n    class ActivityReview {\n        rating: number <<评分>>\n        content: string <<评价内容>>\n        reviewTime: datetime <<评价时间>>\n        required() [\"rating\", \"reviewTime\"]\n    }\n\n    %% 关联关系\n    Activity \"1\" --> \"n\" ActivityReservation : activity2reservation\n    ReservationSystemUser \"1\" --> \"n\" ActivityReservation : user2reservation\n    Activity \"n\" --> \"m\" ActivityCategory : categories\n    Activity \"n\" <-- \"m\" ActivityCategory : activities\n    Activity \"1\" --> \"n\" ActivityReview : activity2review\n    ReservationSystemUser \"1\" --> \"n\" ActivityReview : user2review\n    \n    %% 类的命名\n    note for Activity \"活动模型\"\n    note for ReservationSystemUser \"用户模型\"\n    note for ActivityReservation \"预约模型\"\n    note for ActivityCategory \"分类模型\"\n    note for ActivityReview \"评价模型\"\n```\n\n这个设计包含以下核心功能：\n1. 用户管理（ReservationSystemUser）：包含用户基本信息和联系方式\n2. 活动管理（Activity）：包含活动详情、时间、地点等信息\n3. 预约管理（ActivityReservation）：记录用户预约活动的情况\n4. 活动分类（ActivityCategory）：对活动进行分类管理\n5. 评价系统（ActivityReview）：用户对活动的评价和评分\n\n关键特性：\n• 使用\n\n• 地理位置使用x-location类型\n\n• 设置了必填字段和唯一约束\n\n• 包含默认值设置（如最大参与人数默认为100）\n\n• 使用标准类型映射（如phone、email等）", "name": "activity_reservation" };

package/lib/cjs/utils/mermaid-datasource/prompts/cases/index.d.ts

@@ -0,0 +1,6 @@
+export declare const cases: {
+    user: string;
+    assistant: string;
+    name: string;
+}[];
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/utils/mermaid-datasource/prompts/cases/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/mermaid-datasource/prompts/cases/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,KAAK;;;;GAGjB,CAAC"}