nsgm-cli 2.1.13 → 2.1.15

package/lib/generators/resolver-generator.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolverGenerator = void 0;
+const base_generator_1 = require("./base-generator");
+/**
+ * Resolver生成器
+ */
+class ResolverGenerator extends base_generator_1.BaseGenerator {
+    generate() {
+        const selectFields = this.fields.map((f) => f.name).join(', ');
+        const insertFields = this.getFormFields();
+        const searchableFields = this.getSearchableFields();
+        const insertFieldNames = insertFields.map((f) => f.name).join(', ');
+        const insertPlaceholders = insertFields.map(() => '?').join(', ');
+        const insertValues = insertFields
+            .map((f) => {
+            if (f.type === 'integer') {
+                return `valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)}`;
+            }
+            return `data.${f.name}`;
+        })
+            .join(', ');
+        const searchConditions = this.generateSearchConditions(searchableFields);
+        const updateFields = insertFields.map((f) => `${f.name} = ?`).join(', ');
+        return `const { executeQuery, executePaginatedQuery } = require('../../utils/common')
+const { validateInteger, validatePagination, validateId } = require('../../utils/validation')
+
+module.exports = {
+    // 获取${this.controller}列表（分页）
+    ${this.controller}: async ({ page = 0, pageSize = 10 }) => {
+        try {
+            const { page: validPage, pageSize: validPageSize } = validatePagination(page, pageSize);
+            
+            const sql = 'SELECT ${selectFields} FROM ${this.controller} LIMIT ? OFFSET ?';
+            const countSql = 'SELECT COUNT(*) as counts FROM ${this.controller}';
+            const values = [validPageSize, validPage * validPageSize];
+
+            console.log('执行分页查询:', { sql, values, countSql });
+            
+            return await executePaginatedQuery(sql, countSql, values);
+        } catch (error) {
+            console.error('获取${this.controller}列表失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 根据ID获取${this.controller}
+    ${this.controller}Get: async ({ id }) => {
+        try {
+            const validId = validateId(id);
+            
+            const sql = 'SELECT ${selectFields} FROM ${this.controller} WHERE id = ?';
+            const values = [validId];
+
+            console.log('根据ID查询${this.controller}:', { sql, values });
+            
+            const results = await executeQuery(sql, values);
+            
+            if (results.length === 0) {
+                throw new Error(\`ID为 \${validId} 的${this.controller}不存在\`);
+            }
+            
+            return results[0];
+        } catch (error) {
+            console.error('获取${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 搜索${this.controller}（分页）
+    ${this.controller}Search: async ({ page = 0, pageSize = 10, data = {} }) => {
+        try {
+            const { page: validPage, pageSize: validPageSize } = validatePagination(page, pageSize);
+            
+            const values = [];
+            const countValues = [];
+            
+            let whereSql = '';
+${searchConditions}
+
+            const sql = \`SELECT ${selectFields} FROM ${this.controller} WHERE 1=1\${whereSql} LIMIT ? OFFSET ?\`;
+            const countSql = \`SELECT COUNT(*) as counts FROM ${this.controller} WHERE 1=1\${whereSql}\`;
+            
+            values.push(validPageSize, validPage * validPageSize);
+            
+            console.log('搜索${this.controller}:', { sql, values, countSql, countValues });
+            
+            return await executePaginatedQuery(sql, countSql, values, countValues);
+        } catch (error) {
+            console.error('搜索${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 添加${this.controller}
+    ${this.controller}Add: async ({ data }) => {
+        try {
+${this.generateNewValidationCalls(insertFields)}
+            
+            const sql = 'INSERT INTO ${this.controller} (${insertFieldNames}) VALUES (${insertPlaceholders})';
+            const values = [${insertValues}];
+            
+            console.log('添加${this.controller}:', { sql, values });
+            
+            const results = await executeQuery(sql, values);
+            return results.insertId;
+        } catch (error) {
+            console.error('添加${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 批量添加${this.controller}
+    ${this.controller}BatchAdd: async ({ datas }) => {
+        try {
+            if (!Array.isArray(datas) || datas.length === 0) {
+                throw new Error('批量添加数据不能为空');
+            }
+            
+            // 验证所有数据并转换
+            const validatedDatas = datas.map((data, index) => {
+                try {
+${this.generateBatchValidation(insertFields)}
+                    return { ${this.generateBatchReturnObject(insertFields)} };
+                } catch (error) {
+                    throw new Error(\`第 \${index + 1} 条数据验证失败: \${error.message}\`);
+                }
+            });
+            
+            const placeholders = validatedDatas.map(() => '(${insertPlaceholders})').join(',');
+            const sql = \`INSERT INTO ${this.controller} (${insertFieldNames}) VALUES \${placeholders}\`;
+            const values = validatedDatas.flatMap(data => [${this.generateBatchInsertValues(insertFields)}]);
+            
+            console.log('批量添加${this.controller}:', { sql, values });
+            
+            const results = await executeQuery(sql, values);
+            return results.insertId;
+        } catch (error) {
+            console.error('批量添加${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 更新${this.controller}
+    ${this.controller}Update: async ({ id, data }) => {
+        try {
+            const validId = validateId(id);
+            
+            if (!data) {
+                throw new Error('更新数据不能为空');
+            }
+            
+${this.generateUpdateValidation(insertFields)}
+            
+            const sql = 'UPDATE ${this.controller} SET ${updateFields} WHERE id = ?';
+            const values = [${this.generateUpdateValues(insertFields)}, validId];
+            
+            console.log('更新${this.controller}:', { sql, values });
+            
+            const results = await executeQuery(sql, values);
+            
+            if (results.affectedRows === 0) {
+                throw new Error(\`ID为 \${validId} 的${this.controller}不存在\`);
+            }
+            
+            return true;
+        } catch (error) {
+            console.error('更新${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 删除${this.controller}
+    ${this.controller}Delete: async ({ id }) => {
+        try {
+            const validId = validateId(id);
+            
+            const sql = 'DELETE FROM ${this.controller} WHERE id = ?';
+            const values = [validId];
+            
+            console.log('删除${this.controller}:', { sql, values });
+            
+            const results = await executeQuery(sql, values);
+            
+            if (results.affectedRows === 0) {
+                throw new Error(\`ID为 \${validId} 的${this.controller}不存在\`);
+            }
+            
+            return true;
+        } catch (error) {
+            console.error('删除${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 批量删除${this.controller}
+    ${this.controller}BatchDelete: async ({ ids }) => {
+        try {
+            if (!Array.isArray(ids) || ids.length === 0) {
+                throw new Error('批量删除的ID列表不能为空');
+            }
+            
+            // 验证所有ID
+            const validIds = ids.map((id, index) => {
+                try {
+                    return validateId(id, \`第\${index + 1}个ID\`);
+                } catch (error) {
+                    throw new Error(\`第 \${index + 1} 个ID验证失败: \${error.message}\`);
+                }
+            });
+            
+            const placeholders = validIds.map(() => '?').join(',');
+            const sql = \`DELETE FROM ${this.controller} WHERE id IN (\${placeholders})\`;
+            
+            console.log('批量删除${this.controller}:', { sql, values: validIds });
+            
+            const results = await executeQuery(sql, validIds);
+            
+            if (results.affectedRows === 0) {
+                throw new Error('没有找到要删除的${this.controller}');
+            }
+            
+            return true;
+        } catch (error) {
+            console.error('批量删除${this.controller}失败:', error.message);
+            throw error;
+        }
+    }
+}`;
+    }
+    generateSearchConditions(searchableFields) {
+        if (searchableFields.length === 0)
+            return '';
+        const conditions = searchableFields.map((field) => {
+            if (field.type === 'varchar' || field.type === 'text') {
+                return `            if (data.${field.name} && data.${field.name}.trim() !== '') {
+                whereSql += ' AND ${field.name} LIKE ?';
+                const ${field.name}Pattern = \`%\${data.${field.name}.trim()}%\`;
+                values.push(${field.name}Pattern);
+                countValues.push(${field.name}Pattern);
+            }`;
+            }
+            else if (field.type === 'integer') {
+                return `            if (data.${field.name} !== undefined && data.${field.name} !== null && data.${field.name} !== '') {
+                // 使用通用验证工具验证 ${field.name}
+                const valid${field.name.charAt(0).toUpperCase() + field.name.slice(1)} = validateInteger(data.${field.name}, '${field.name}', { min: 0, max: 150 });
+                if (valid${field.name.charAt(0).toUpperCase() + field.name.slice(1)} !== undefined) {
+                    whereSql += ' AND ${field.name} = ?';
+                    values.push(valid${field.name.charAt(0).toUpperCase() + field.name.slice(1)});
+                    countValues.push(valid${field.name.charAt(0).toUpperCase() + field.name.slice(1)});
+                }
+            }`;
+            }
+            else {
+                return `            if (data.${field.name} !== undefined && data.${field.name} !== null) {
+                whereSql += ' AND ${field.name} = ?';
+                values.push(data.${field.name});
+                countValues.push(data.${field.name});
+            }`;
+            }
+        });
+        return conditions.join('\n\n');
+    }
+    generateNewValidationCalls(insertFields) {
+        return insertFields
+            .map((f) => {
+            if (f.type === 'integer') {
+                const validationOptions = f.name === 'age' ? '{ min: 0, max: 150, required: true }' : '{ required: true }';
+                return `            const valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)} = validateInteger(data.${f.name}, '${f.name}', ${validationOptions});`;
+            }
+            else if (f.required) {
+                return `            if (!data.${f.name}) {
+                throw new Error('${f.comment || f.name}是必填字段');
+            }`;
+            }
+            return '';
+        })
+            .filter((call) => call.length > 0)
+            .join('\n');
+    }
+    generateBatchValidation(insertFields) {
+        return insertFields
+            .map((f) => {
+            if (f.type === 'integer') {
+                const validationOptions = f.name === 'age' ? '{ min: 0, max: 150, required: true }' : '{ required: true }';
+                return `                    const valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)} = validateInteger(data.${f.name}, \`第\${index + 1}条数据的${f.name}\`, ${validationOptions});`;
+            }
+            else if (f.required) {
+                return `                    if (!data.${f.name}) {
+                        throw new Error('${f.comment || f.name}是必填字段');
+                    }`;
+            }
+            return '';
+        })
+            .filter((call) => call.length > 0)
+            .join('\n');
+    }
+    generateUpdateValidation(insertFields) {
+        return insertFields
+            .map((f) => {
+            if (f.type === 'integer') {
+                const validationOptions = f.name === 'age' ? '{ min: 0, max: 150, required: true }' : '{ required: true }';
+                return `            let valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)} = data.${f.name};
+            if (data.${f.name} !== undefined) {
+                valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)} = validateInteger(data.${f.name}, '${f.name}', ${validationOptions});
+            }`;
+            }
+            else if (f.required) {
+                return `            if (data.${f.name} !== undefined && !data.${f.name}) {
+                throw new Error('${f.comment || f.name}是必填字段');
+            }`;
+            }
+            return '';
+        })
+            .filter((call) => call.length > 0)
+            .join('\n');
+    }
+    generateUpdateValues(insertFields) {
+        return insertFields
+            .map((f) => {
+            if (f.type === 'integer') {
+                return `valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)}`;
+            }
+            return `data.${f.name}`;
+        })
+            .join(', ');
+    }
+    generateBatchReturnObject(insertFields) {
+        return insertFields
+            .map((f) => {
+            if (f.type === 'integer') {
+                return `${f.name}: valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)}`;
+            }
+            return `${f.name}: data.${f.name}`;
+        })
+            .join(', ');
+    }
+    generateBatchInsertValues(insertFields) {
+        return insertFields.map((f) => `data.${f.name}`).join(', ');
+    }
+}
+exports.ResolverGenerator = ResolverGenerator;

package/lib/generators/schema-generator.d.ts

@@ -0,0 +1,7 @@
+import { BaseGenerator } from './base-generator';
+/**
+ * GraphQL Schema生成器
+ */
+export declare class SchemaGenerator extends BaseGenerator {
+    generate(): string;
+}

package/lib/generators/schema-generator.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaGenerator = void 0;
+const base_generator_1 = require("./base-generator");
+/**
+ * GraphQL Schema生成器
+ */
+class SchemaGenerator extends base_generator_1.BaseGenerator {
+    generate() {
+        const capitalizedTypeName = this.getCapitalizedController();
+        const pluralTypeName = `${capitalizedTypeName}s`;
+        const typeFields = this.getNonSystemFields()
+            .map((field) => `            ${field.name}: ${this.getGraphQLType(field.type)}`)
+            .join('\n');
+        const inputFields = this.getFormFields()
+            .map((field) => `            ${field.name}: ${this.getGraphQLType(field.type)}`)
+            .join('\n');
+        const searchableFields = this.getSearchableFields();
+        const searchFields = searchableFields.length > 0
+            ? searchableFields.map((field) => `            ${field.name}: ${this.getGraphQLType(field.type)}`).join('\n')
+            : '            name: String';
+        return `module.exports = {
+    query: \`
+        ${this.controller}(page: Int, pageSize: Int): ${pluralTypeName}
+        ${this.controller}Get(id: Int): ${capitalizedTypeName}
+        ${this.controller}Search(page: Int, pageSize: Int, data: ${capitalizedTypeName}SearchInput): ${pluralTypeName}
+    \`,
+    mutation: \`
+        ${this.controller}Add(data: ${capitalizedTypeName}AddInput): Int
+        ${this.controller}BatchAdd(datas: [${capitalizedTypeName}AddInput]): Int
+        ${this.controller}Update(id: Int, data: ${capitalizedTypeName}AddInput): Boolean
+        ${this.controller}Delete(id: Int): Boolean
+        ${this.controller}BatchDelete(ids: [Int]): Boolean
+    \`,
+    subscription: \`\`,
+    type: \`
+        type ${capitalizedTypeName} {
+${typeFields}
+        }
+
+        type ${pluralTypeName} {
+            totalCounts: Int
+            items: [${capitalizedTypeName}]
+        }
+
+        input ${capitalizedTypeName}AddInput {
+${inputFields}
+        }
+
+        input ${capitalizedTypeName}SearchInput {
+${searchFields}
+        }
+    \`
+}`;
+    }
+}
+exports.SchemaGenerator = SchemaGenerator;

package/lib/generators/service-generator.d.ts

@@ -0,0 +1,11 @@
+import { BaseGenerator } from './base-generator';
+/**
+ * 客户端服务生成器
+ */
+export declare class ServiceGenerator extends BaseGenerator {
+    generate(): string;
+    private generateValidationFunctions;
+    private generateValidationCallsForService;
+    private generateDataObjectWithValidation;
+    private generateBatchValidationCalls;
+}

package/lib/generators/service-generator.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceGenerator = void 0;
+const base_generator_1 = require("./base-generator");
+/**
+ * 客户端服务生成器
+ */
+class ServiceGenerator extends base_generator_1.BaseGenerator {
+    generate() {
+        const capitalizedTypeName = this.getCapitalizedController();
+        // 排除系统字段 create_date 和 update_date
+        const selectFields = this.fields
+            .filter((f) => !['create_date', 'update_date'].includes(f.name))
+            .map((f) => f.name)
+            .join(' ');
+        const inputFields = this.getFormFields();
+        const searchFields = this.getSearchableFields();
+        // 检查是否有integer类型字段需要验证
+        const hasIntegerFields = inputFields.some((field) => field.type === 'integer');
+        const validationFunctions = hasIntegerFields ? this.generateValidationFunctions(inputFields) : '';
+        return `import { getLocalGraphql } from '@/utils/fetch'
+import _ from 'lodash'
+
+${validationFunctions}
+
+export const get${capitalizedTypeName}Service = (page = 0, pageSize = 10) => {
+  const get${capitalizedTypeName}Query = \`query ($page: Int, $pageSize: Int) { ${this.controller}(page: $page, pageSize: $pageSize) { 
+        totalCounts items { 
+          ${selectFields}
+        } 
+      } 
+    }\`
+
+  return getLocalGraphql(get${capitalizedTypeName}Query, {
+    page,
+    pageSize
+  })
+}
+
+export const search${capitalizedTypeName}ByIdService = (id: number) => {
+  const search${capitalizedTypeName}ByIdQuery = \`query ($id: Int) { ${this.controller}Get(id: $id){
+      ${selectFields}
+    }
+  }\`
+
+  return getLocalGraphql(search${capitalizedTypeName}ByIdQuery, {
+    id
+  })
+}
+
+export const search${capitalizedTypeName}Service = (page = 0, pageSize = 10, data: any) => {
+  const { ${searchFields.map((f) => f.name).join(', ')} } = data
+
+${this.generateValidationCallsForService(searchFields, '  ', false)}
+
+  const search${capitalizedTypeName}Query = \`query ($page: Int, $pageSize: Int, $data: ${capitalizedTypeName}SearchInput) { 
+    ${this.controller}Search(page: $page, pageSize: $pageSize, data: $data) {
+      totalCounts items { 
+        ${selectFields}
+      } 
+    }
+  }\`
+
+  return getLocalGraphql(search${capitalizedTypeName}Query, {
+    page,
+    pageSize,
+    data: {
+${this.generateDataObjectWithValidation(searchFields)}
+    }
+  })
+}
+
+export const add${capitalizedTypeName}Service = (data: any) => {
+  const { ${inputFields.map((f) => f.name).join(', ')} } = data
+
+${this.generateValidationCallsForService(inputFields, '  ', true)}
+
+  const add${capitalizedTypeName}Query = \`mutation ($data: ${capitalizedTypeName}AddInput) { ${this.controller}Add(data: $data) }\`
+
+  return getLocalGraphql(add${capitalizedTypeName}Query, {
+    data: {
+${this.generateDataObjectWithValidation(inputFields)}
+    }
+  })
+}
+
+export const update${capitalizedTypeName}Service = (id: number, data: any) => {
+  const { ${inputFields.map((f) => f.name).join(', ')} } = data
+
+${this.generateValidationCallsForService(inputFields, '  ', true)}
+
+  const update${capitalizedTypeName}Query = \`mutation ($id: Int, $data: ${capitalizedTypeName}AddInput) { ${this.controller}Update(id: $id, data: $data) }\`
+
+  return getLocalGraphql(update${capitalizedTypeName}Query, {
+    id,
+    data: {
+${this.generateDataObjectWithValidation(inputFields)}
+    }
+  })
+}
+
+export const delete${capitalizedTypeName}Service = (id: number) => {
+  const delete${capitalizedTypeName}Query = \`mutation ($id: Int) { ${this.controller}Delete(id: $id) }\`
+
+  return getLocalGraphql(delete${capitalizedTypeName}Query, {
+    id
+  })
+}
+
+export const batchAdd${capitalizedTypeName}Service = (datas: any) => {
+${this.generateBatchValidationCalls(inputFields, '  ')}
+
+  const batchAdd${capitalizedTypeName}Query = \`mutation ($datas: [${capitalizedTypeName}AddInput]) { ${this.controller}BatchAdd(datas: $datas) }\`
+
+  return getLocalGraphql(batchAdd${capitalizedTypeName}Query, {
+    datas: validatedDatas
+  })
+}
+
+export const batchDelete${capitalizedTypeName}Service = (ids: any) => {
+  const batchDelete${capitalizedTypeName}Query = \`mutation ($ids: [Int]) { ${this.controller}BatchDelete(ids: $ids) }\`
+
+  return getLocalGraphql(batchDelete${capitalizedTypeName}Query, {
+    ids
+  })
+}
+`;
+    }
+    generateValidationFunctions(inputFields) {
+        const integerFields = inputFields.filter((field) => field.type === 'integer');
+        if (integerFields.length === 0) {
+            return '';
+        }
+        const validationFunctions = integerFields.map((field) => {
+            const fieldName = field.name;
+            const capitalizedName = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
+            const upperFieldName = fieldName.toUpperCase();
+            return `// 简化的${fieldName}验证函数
+const validate${capitalizedName} = (${fieldName}: any, required = false) => {
+  if (${fieldName} === undefined || ${fieldName} === null || ${fieldName} === '') {
+    if (required) {
+      return { valid: false, error: '${fieldName}是必填字段', code: 'REQUIRED_${upperFieldName}_MISSING' }
+    }
+    return { valid: true, value: undefined }
+  }
+
+  const parsed${capitalizedName} = parseInt(${fieldName}, 10)
+  if (isNaN(parsed${capitalizedName})) {
+    return {
+      valid: false,
+      error: \`${fieldName}必须是数字，收到的值: "\${${fieldName}}"\`,
+      code: 'INVALID_${upperFieldName}_FORMAT'
+    }
+  }
+
+  return { valid: true, value: parsed${capitalizedName} }
+}`;
+        });
+        return `${validationFunctions.join('\n\n')}\n\n`;
+    }
+    generateValidationCallsForService(inputFields, indent, required) {
+        const integerFields = inputFields.filter((field) => field.type === 'integer');
+        if (integerFields.length === 0) {
+            return '';
+        }
+        const validationCalls = integerFields.map((field) => {
+            const fieldName = field.name;
+            const capitalizedName = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
+            const requiredStr = required ? 'true' : 'false';
+            return `${indent}// 验证${required ? '必填' : ''}${fieldName}
+${indent}const ${fieldName}Validation = validate${capitalizedName}(${fieldName}, ${requiredStr})
+${indent}if (!${fieldName}Validation.valid) {
+${indent}  return Promise.reject({
+${indent}    error: true,
+${indent}    message: ${fieldName}Validation.error,
+${indent}    code: ${fieldName}Validation.code
+${indent}  })
+${indent}}`;
+        });
+        return validationCalls.join('\n\n') + (validationCalls.length > 0 ? '\n\n' : '');
+    }
+    generateDataObjectWithValidation(inputFields) {
+        return inputFields
+            .map((field) => {
+            if (field.type === 'integer') {
+                return `      ${field.name}: ${field.name}Validation.value`;
+            }
+            return `      ${field.name}`;
+        })
+            .join(',\n');
+    }
+    generateBatchValidationCalls(inputFields, indent) {
+        const integerFields = inputFields.filter((field) => field.type === 'integer');
+        if (integerFields.length === 0) {
+            return `${indent}// 验证批量数据
+${indent}const validatedDatas: Array<{ ${inputFields.map((f) => `${f.name}: any`).join('; ')} }> = []
+
+${indent}for (let i = 0; i < datas.length; i++) {
+${indent}  const { ${inputFields.map((f) => f.name).join(', ')} } = datas[i]
+
+${indent}  validatedDatas.push({
+${indent}    ${inputFields.map((f) => f.name).join(',\n    ')}
+${indent}  })
+${indent}}`;
+        }
+        return `${indent}// 验证批量数据
+${indent}const validatedDatas: Array<{ ${inputFields.map((f) => `${f.name}: ${f.type === 'integer' ? 'number' : 'any'}`).join('; ')} }> = []
+
+${indent}for (let i = 0; i < datas.length; i++) {
+${indent}  const { ${inputFields.map((f) => f.name).join(', ')} } = datas[i]
+
+${integerFields
+            .map((field) => {
+            const fieldName = field.name;
+            const capitalizedName = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
+            return `${indent}  const ${fieldName}Validation = validate${capitalizedName}(${fieldName}, true)
+${indent}  if (!${fieldName}Validation.valid) {
+${indent}    return Promise.reject({
+${indent}      error: true,
+${indent}      message: \`第 \${i + 1} 条数据: \${${fieldName}Validation.error}\`,
+${indent}      code: ${fieldName}Validation.code
+${indent}    })
+${indent}  }`;
+        })
+            .join('\n\n')}
+
+${indent}  validatedDatas.push({
+${indent}    ${inputFields.map((field) => (field.type === 'integer' ? `${field.name}: ${field.name}Validation.value!` : field.name)).join(',\n    ')}
+${indent}  })
+${indent}}`;
+    }
+}
+exports.ServiceGenerator = ServiceGenerator;

package/lib/generators/sql-generator.d.ts

@@ -0,0 +1,8 @@
+import { BaseGenerator } from './base-generator';
+/**
+ * SQL生成器
+ * 专门负责生成数据库表结构
+ */
+export declare class SQLGenerator extends BaseGenerator {
+    generate(): string;
+}