@lark-apaas/devtool-kits 1.1.0 → 1.2.0-alpha.0

package/dist/index.js

@@ -514,6 +514,673 @@ function postprocessDrizzleSchema(targetPath) {
 }
 __name(postprocessDrizzleSchema, "postprocessDrizzleSchema");
 
+// src/helpers/gen-nest-resource/utils.ts
+function mapDrizzleTypeToTS(field) {
+  const typeMap = {
+    // String types
+    char: "string",
+    varchar: "string",
+    text: "string",
+    // Numeric types
+    smallint: "number",
+    integer: "number",
+    int: "number",
+    bigint: "string",
+    serial: "number",
+    smallserial: "number",
+    bigserial: "string",
+    // Decimal types
+    decimal: "string",
+    numeric: "string",
+    real: "number",
+    doublePrecision: "number",
+    // Boolean
+    boolean: "boolean",
+    // Date/Time types
+    timestamp: "Date",
+    timestamptz: "Date",
+    date: "Date",
+    time: "string",
+    timetz: "string",
+    interval: "string",
+    // UUID
+    uuid: "string",
+    // JSON types
+    json: "any",
+    jsonb: "any",
+    // Binary
+    bytea: "Buffer",
+    // Network types
+    inet: "string",
+    cidr: "string",
+    macaddr: "string",
+    macaddr8: "string",
+    // Geometric types
+    point: "{ x: number; y: number }",
+    line: "string",
+    lseg: "string",
+    box: "string",
+    path: "string",
+    polygon: "string",
+    circle: "string",
+    // Array types (handled by isArray flag)
+    array: "any[]",
+    // Custom types
+    customType: "any",
+    customTimestamptz: "Date",
+    userProfile: "string",
+    fileAttachment: "FileAttachment",
+    // Enum (handled separately)
+    pgEnum: "string"
+  };
+  let baseType = typeMap[field.type] || "any";
+  if (field.isArray) {
+    baseType = baseType.endsWith("[]") ? baseType : `${baseType}[]`;
+  }
+  if (field.enumValues && field.enumValues.length > 0) {
+    baseType = field.enumValues.map((v) => `'${v}'`).join(" | ");
+  }
+  return baseType;
+}
+__name(mapDrizzleTypeToTS, "mapDrizzleTypeToTS");
+function toPascalCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_\s]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase().replace(/[_\s]/g, "-");
+}
+__name(toKebabCase, "toKebabCase");
+
+// src/helpers/gen-nest-resource/generator.ts
+function generateDTO(table) {
+  const className = toPascalCase(table.variableName);
+  let dto = `// \u8BF7\u4FEE\u6539\u8BE5\u6587\u4EF6\u4EE3\u7801\u4EE5\u6EE1\u8DB3\u9700\u6C42
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDefined, IsNumber, IsOptional, IsString, MaxLength, IsInt, IsBoolean, IsUUID, IsDate, IsObject, IsArray } from 'class-validator';
+import { Type } from 'class-transformer';
+import { FileAttachment } from '../../../database/schema';
+
+`;
+  dto += `export class Create${className}Dto {
+`;
+  for (const field of table.fields) {
+    if (field.isPrimaryKey || field.name === "id" || field.name.startsWith("_") || field.name.startsWith("created") || field.name.startsWith("updated")) {
+      continue;
+    }
+    const tsType = mapDrizzleTypeToTS(field);
+    const optional = field.nullable || field.hasDefault ? "?" : "";
+    const decorators = generateValidationDecorators(field);
+    if (decorators) {
+      dto += decorators;
+    }
+    dto += `  ${field.name}${optional}: ${tsType};
+
+`;
+  }
+  dto += "}\n\n";
+  dto += `export class Update${className}Dto {
+`;
+  for (const field of table.fields) {
+    if (field.name.startsWith("_") || field.name.startsWith("created") || field.name.startsWith("updated") || field.isPrimaryKey || field.name === "id") {
+      continue;
+    }
+    const tsType = mapDrizzleTypeToTS(field);
+    const decorators = generateValidationDecorators(field, {
+      isUpdate: true
+    });
+    if (decorators) {
+      dto += decorators;
+    }
+    dto += `  ${field.name}?: ${tsType};
+
+`;
+  }
+  dto += "}\n\n";
+  dto += `export class ${className}ResponseDto {
+`;
+  for (const field of table.fields) {
+    const tsType = mapDrizzleTypeToTS(field);
+    const optional = field.nullable ? "?" : "";
+    const decorators = generateValidationDecorators(field, {
+      isResponse: true
+    });
+    if (decorators) {
+      dto += decorators;
+    }
+    dto += `  ${field.name}${optional}: ${tsType};
+
+`;
+  }
+  dto += "}\n";
+  return dto;
+}
+__name(generateDTO, "generateDTO");
+function generateValidationDecorators(field, { isUpdate = false, isResponse = false } = {}) {
+  let decorators = "  // \u8BF7\u6309\u7528\u6237\u9700\u6C42\u4FEE\u6539\u4EE5\u4E0B\u88C5\u9970\u5668\u6CE8\u91CA\n";
+  if (field.nullable || !isResponse && field.hasDefault || isUpdate) {
+    decorators += `  @ApiPropertyOptional({ description: '${field.comment || field.name}' })
+`;
+    if (isResponse) {
+      return decorators;
+    }
+    decorators += "  @IsOptional()\n";
+  } else {
+    decorators += `  @ApiProperty({ description: '${field.comment || field.name}' })
+`;
+    if (isResponse) {
+      return decorators;
+    }
+    decorators += "  @IsDefined()\n";
+  }
+  switch (field.type) {
+    case "varchar":
+    case "char":
+    case "text":
+      decorators += "  @IsString()\n";
+      if (field.length) {
+        decorators += `  @MaxLength(${field.length})
+`;
+      }
+      break;
+    case "integer":
+    case "smallint":
+    case "serial":
+    case "smallserial":
+      decorators += "  @IsInt()\n";
+      break;
+    case "decimal":
+    case "numeric":
+    case "real":
+    case "doublePrecision":
+      decorators += "  @IsNumber()\n";
+      break;
+    case "boolean":
+      decorators += "  @IsBoolean()\n";
+      break;
+    case "uuid":
+      decorators += "  @IsUUID()\n";
+      break;
+    case "timestamp":
+    case "timestamptz":
+    case "date":
+    case "customTimestamptz":
+      decorators += "  @IsDate()\n";
+      break;
+    case "json":
+    case "jsonb":
+      decorators += "  @IsObject()\n";
+      break;
+  }
+  if (field.isArray) {
+    decorators += "  @IsArray()\n";
+  }
+  return decorators;
+}
+__name(generateValidationDecorators, "generateValidationDecorators");
+function generateController(table) {
+  const className = toPascalCase(table.variableName);
+  const routePath = toKebabCase(table.variableName);
+  const pkField = table.fields.find((f) => f.isPrimaryKey);
+  const pkType = pkField ? mapDrizzleTypeToTS(pkField) : "string";
+  const pkName = pkField ? pkField.name : "id";
+  const controller = `
+// \u8BF7\u4FEE\u6539\u8BE5\u6587\u4EF6\u4EE3\u7801\u4EE5\u6EE1\u8DB3\u9700\u6C42
+import { 
+  Controller, 
+  Get, 
+  Post, 
+  Put, 
+  Delete, 
+  Body, 
+  Param, 
+  Query,
+} from '@nestjs/common';
+ import {
+  ApiTags,
+  ApiOperation,
+  ApiOkResponse,
+  ApiCreatedResponse,
+} from '@nestjs/swagger';
+import { 
+  Create${className}Dto, 
+  Update${className}Dto,
+  ${className}ResponseDto
+} from './dtos/${routePath}.dto';
+import { ${className}Service } from './${routePath}.service';
+
+@ApiTags('${toPascalCase(table.variableName)}')
+@Controller('api/${routePath}')
+export class ${className}Controller {
+  constructor(private readonly ${table.variableName}Service: ${className}Service) {}
+
+  @Post()
+  @ApiOperation({
+    summary: '\u521B\u5EFA\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u521B\u5EFA\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiCreatedResponse({
+    description: '\u6210\u529F\u521B\u5EFA\u4E00\u6761\u8BB0\u5F55',
+    type: ${className}ResponseDto,
+  })
+  async create(
+    @Body() createDto: Create${className}Dto
+  ): Promise<${className}ResponseDto> {
+    return this.${table.variableName}Service.create(createDto);
+  }
+
+  @ApiOperation({
+    summary: '\u6839\u636E\u4E3B\u952E\u67E5\u8BE2\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u6839\u636E\u4E3B\u952E\u67E5\u8BE2\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiOkResponse({
+    description: '\u6210\u529F\u67E5\u8BE2\u4E00\u6761\u8BB0\u5F55',
+    type: ${className}ResponseDto,
+  })
+  @Get(':${pkName}')
+  async findOne(
+    @Param('${pkName}') ${pkName}: ${pkType}
+  ): Promise<${className}ResponseDto> {
+    return this.${table.variableName}Service.findOne(${pkName});
+  }
+
+  @ApiOperation({
+    summary: '\u6839\u636E\u4E3B\u952E\u66F4\u65B0\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u6839\u636E\u4E3B\u952E\u66F4\u65B0\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiOkResponse({
+    description: '\u6210\u529F\u66F4\u65B0\u4E00\u6761\u8BB0\u5F55',
+    type: ${className}ResponseDto,
+  })
+  @Put(':${pkName}')
+  async update(
+    @Param('${pkName}') ${pkName}: ${pkType},
+    @Body() updateDto: Update${className}Dto
+  ): Promise<${className}ResponseDto> {
+    return this.${table.variableName}Service.update(${pkName}, updateDto);
+  }
+
+  @ApiOperation({
+    summary: '\u6839\u636E\u4E3B\u952E\u5220\u9664\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+    description: '\u6839\u636E\u4E3B\u952E\u5220\u9664\u4E00\u6761\u8BB0\u5F55\uFF08\u6A21\u677F\u5185\u5BB9\uFF0C\u8BF7\u4FEE\u6539\u6211\uFF09',
+  })
+  @ApiOkResponse({
+    description: '\u6210\u529F\u5220\u9664\u4E00\u6761\u8BB0\u5F55',
+  })
+  @Delete(':${pkName}')
+  async remove(
+    @Param('${pkName}') ${pkName}: ${pkType}
+  ): Promise<void> {
+    return this.${table.variableName}Service.remove(${pkName});
+  }
+}
+`;
+  return controller;
+}
+__name(generateController, "generateController");
+function generateService(table) {
+  const className = toPascalCase(table.variableName);
+  const routePath = toKebabCase(table.variableName);
+  const pkField = table.fields.find((f) => f.isPrimaryKey);
+  const pkType = pkField ? mapDrizzleTypeToTS(pkField) : "string";
+  const pkName = pkField ? pkField.name : "id";
+  const service = `
+// \u8BF7\u4FEE\u6539\u8BE5\u6587\u4EF6\u4EE3\u7801\u4EE5\u6EE1\u8DB3\u9700\u6C42
+import { Injectable, Inject, Logger, NotFoundException } from '@nestjs/common';
+import { eq } from 'drizzle-orm';
+import { DRIZZLE_DATABASE, type PostgresJsDatabase } from '@lark-apaas/fullstack-nestjs-core';
+import { ${table.variableName} } from '../../database/schema';
+import { 
+  Create${className}Dto, 
+  Update${className}Dto,
+  ${className}ResponseDto 
+} from './dtos/${routePath}.dto';
+
+@Injectable()
+export class ${className}Service {
+  private readonly logger = new Logger(${className}Service.name);
+
+  constructor(@Inject(DRIZZLE_DATABASE) private readonly db: PostgresJsDatabase) {}
+
+  async create(createDto: Create${className}Dto): Promise<${className}ResponseDto> {
+    const [result] = await this.db
+      .insert(${table.variableName})
+      .values(createDto)
+      .returning();
+
+    this.logger.log(\`Created ${className} with ${pkName} \${result.${pkName}}\`);
+    
+    return result;
+  }
+
+  async findAll(options?: { page?: number; limit?: number }): Promise<${className}ResponseDto[]> {
+    const { page = 1, limit = 10 } = options || {};
+    const offset = (page - 1) * limit;
+
+    return this.db
+      .select()
+      .from(${table.variableName})
+      .limit(limit)
+      .offset(offset);
+  }
+
+  async findOne(${pkName}: ${pkType}): Promise<${className}ResponseDto> {
+    const [result] = await this.db
+      .select()
+      .from(${table.variableName})
+      .where(eq(${table.variableName}.${pkName}, ${pkName}))
+      .limit(1);
+
+    if (!result) {
+      throw new NotFoundException(\`${className} with ${pkName} \${${pkName}} not found\`);
+    }
+
+    return result;
+  }
+
+  async update(${pkName}: ${pkType}, updateDto: Update${className}Dto): Promise<${className}ResponseDto> {
+    const [result] = await this.db
+      .update(${table.variableName})
+      .set(updateDto)
+      .where(eq(${table.variableName}.${pkName}, ${pkName}))
+      .returning();
+
+    if (!result) {
+      throw new NotFoundException(\`${className} with ${pkName} \${${pkName}} not found\`);
+    }
+
+    return result;
+  }
+
+  async remove(${pkName}: ${pkType}): Promise<void> {
+    const result = await this.db
+      .delete(${table.variableName})
+      .where(eq(${table.variableName}.${pkName}, ${pkName}))
+      .returning();
+
+    if (result.length === 0) {
+      throw new NotFoundException(\`${className} with ${pkName} \${${pkName}} not found\`);
+    }
+
+    this.logger.log(\`Deleted ${className} with ${pkName} \${${pkName}}\`);
+  }
+}
+`;
+  return service;
+}
+__name(generateService, "generateService");
+function generateModule(table) {
+  const className = toPascalCase(table.variableName);
+  const routePath = toKebabCase(table.variableName);
+  const module = `
+import { Module } from '@nestjs/common';
+import { ${className}Controller } from './${routePath}.controller';
+import { ${className}Service } from './${routePath}.service';
+
+@Module({
+  controllers: [${className}Controller],
+  providers: [${className}Service],
+})
+export class ${className}Module {}
+`;
+  return module;
+}
+__name(generateModule, "generateModule");
+
+// src/helpers/gen-nest-resource/schema-parser.ts
+import { Project, Node } from "ts-morph";
+var DrizzleSchemaParser = class DrizzleSchemaParser2 {
+  static {
+    __name(this, "DrizzleSchemaParser");
+  }
+  project;
+  constructor(projectOptions) {
+    this.project = new Project(projectOptions);
+  }
+  parseSchemaFile(filePath) {
+    const sourceFile = this.project.addSourceFileAtPath(filePath);
+    const tables = [];
+    const variableStatements = sourceFile.getVariableStatements();
+    for (const statement of variableStatements) {
+      const declarations = statement.getDeclarations();
+      for (const declaration of declarations) {
+        const initializer = declaration.getInitializer();
+        if (initializer && Node.isCallExpression(initializer)) {
+          const expression = initializer.getExpression();
+          if (expression.getText() === "pgTable") {
+            const tableInfo = this.parsePgTable(declaration.getName(), initializer);
+            if (tableInfo) {
+              tables.push(tableInfo);
+            }
+          }
+        }
+      }
+    }
+    return tables;
+  }
+  parsePgTable(variableName, callExpr) {
+    const args = callExpr.getArguments();
+    if (args.length < 2) {
+      return null;
+    }
+    const tableName = args[0].getText().replace(/['"]/g, "");
+    const fieldsArg = args[1];
+    if (!Node.isObjectLiteralExpression(fieldsArg)) {
+      return null;
+    }
+    const fields = [];
+    const properties = fieldsArg.getProperties();
+    for (const prop of properties) {
+      if (Node.isPropertyAssignment(prop)) {
+        const fieldName = prop.getName();
+        const initializer = prop.getInitializer();
+        const leadingComments = prop.getLeadingCommentRanges();
+        let comment;
+        if (leadingComments.length > 0) {
+          comment = leadingComments.map((c) => c.getText()).join("\n").replace(/\/\//g, "").trim();
+        }
+        if (initializer && Node.isCallExpression(initializer)) {
+          const fieldInfo = this.parseField(fieldName, initializer, comment);
+          fields.push(fieldInfo);
+        }
+      }
+    }
+    return {
+      tableName,
+      variableName,
+      fields
+    };
+  }
+  parseField(fieldName, callExpr, comment) {
+    const fieldInfo = {
+      name: fieldName,
+      columnName: fieldName,
+      type: "",
+      nullable: true,
+      hasDefault: false,
+      notNull: false,
+      isPrimaryKey: false,
+      isUnique: false,
+      isArray: false,
+      comment
+    };
+    this.parseBaseType(callExpr, fieldInfo);
+    this.parseCallChain(callExpr, fieldInfo);
+    return fieldInfo;
+  }
+  parseBaseType(callExpr, fieldInfo) {
+    let current = callExpr;
+    let baseCall = null;
+    while (Node.isCallExpression(current)) {
+      baseCall = current;
+      const expression2 = current.getExpression();
+      if (Node.isPropertyAccessExpression(expression2)) {
+        current = expression2.getExpression();
+      } else {
+        break;
+      }
+    }
+    if (!baseCall) {
+      return;
+    }
+    const expression = baseCall.getExpression();
+    let typeName = "";
+    if (Node.isPropertyAccessExpression(expression)) {
+      typeName = expression.getName();
+    } else {
+      typeName = expression.getText();
+    }
+    fieldInfo.type = typeName;
+    const args = baseCall.getArguments();
+    if (args.length > 0) {
+      const firstArg = args[0];
+      if (Node.isStringLiteral(firstArg)) {
+        fieldInfo.columnName = firstArg.getLiteralText();
+      } else if (Node.isObjectLiteralExpression(firstArg)) {
+        this.parseTypeConfig(firstArg, fieldInfo);
+      } else if (Node.isArrayLiteralExpression(firstArg)) {
+        fieldInfo.enumValues = firstArg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
+      }
+    }
+    if (args.length > 1 && Node.isObjectLiteralExpression(args[1])) {
+      this.parseTypeConfig(args[1], fieldInfo);
+    }
+  }
+  parseTypeConfig(objLiteral, fieldInfo) {
+    if (!Node.isObjectLiteralExpression(objLiteral)) {
+      return;
+    }
+    const properties = objLiteral.getProperties();
+    for (const prop of properties) {
+      if (Node.isPropertyAssignment(prop)) {
+        const propName = prop.getName();
+        const value = prop.getInitializer()?.getText();
+        switch (propName) {
+          case "length":
+            fieldInfo.length = value ? parseInt(value) : void 0;
+            break;
+          case "precision":
+            fieldInfo.precision = value ? parseInt(value) : void 0;
+            break;
+          case "scale":
+            fieldInfo.scale = value ? parseInt(value) : void 0;
+            break;
+          case "default":
+            fieldInfo.hasDefault = true;
+            fieldInfo.defaultValue = value;
+            break;
+          // 时间精度（用于 timestamp, time 等）
+          case "withTimezone":
+            fieldInfo.withTimezone = value === "true";
+            break;
+          case "mode":
+            fieldInfo.mode = value?.replace(/['"]/g, "");
+            break;
+          default:
+            throw new Error(`Unsupported property: ${propName}`);
+        }
+      }
+    }
+  }
+  parseCallChain(callExpr, fieldInfo) {
+    let current = callExpr;
+    while (Node.isCallExpression(current)) {
+      const expression = current.getExpression();
+      if (Node.isPropertyAccessExpression(expression)) {
+        const methodName = expression.getName();
+        const args = current.getArguments();
+        switch (methodName) {
+          case "notNull":
+            fieldInfo.notNull = true;
+            fieldInfo.nullable = false;
+            break;
+          case "default":
+            fieldInfo.hasDefault = true;
+            if (args.length > 0) {
+              fieldInfo.defaultValue = args[0].getText();
+            }
+            break;
+          case "defaultRandom":
+            fieldInfo.hasDefault = true;
+            fieldInfo.defaultValue = "random";
+            break;
+          case "primaryKey":
+            fieldInfo.isPrimaryKey = true;
+            fieldInfo.notNull = true;
+            fieldInfo.nullable = false;
+            break;
+          case "unique":
+            fieldInfo.isUnique = true;
+            break;
+          case "array":
+            fieldInfo.isArray = true;
+            break;
+          case "references":
+            if (args.length > 0) {
+              const refArg = args[0].getText();
+              const match = refArg.match(/=>\s*(\w+)\.(\w+)/);
+              if (match) {
+                fieldInfo.references = {
+                  table: match[1],
+                  column: match[2]
+                };
+              }
+            }
+            break;
+          default:
+            throw new Error(`Unsupported method: ${methodName}`);
+        }
+        current = expression.getExpression();
+      } else {
+        break;
+      }
+    }
+  }
+};
+
+// src/helpers/gen-nest-resource/index.ts
+import { join } from "path";
+import { mkdir, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+async function parseAndGenerateNestResourceTemplate(options) {
+  const parser = new DrizzleSchemaParser({
+    tsConfigFilePath: options.tsConfigFilePath
+  });
+  const tables = parser.parseSchemaFile(options.schemaFilePath);
+  for (const table of tables) {
+    console.info(`\u751F\u6210 Nest.js ${table.variableName} \u6A21\u5757`);
+    const routePath = toKebabCase(table.variableName);
+    const moduleDir = join(options.moduleOutputDir, routePath);
+    if (existsSync(moduleDir)) {
+      console.info(`Nest.js \u6A21\u5757 ${routePath} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u751F\u6210\u4EE3\u7801`);
+      continue;
+    }
+    const dto = generateDTO(table);
+    const controller = generateController(table);
+    const service = generateService(table);
+    const moduleFilePath = join(moduleDir, `${routePath}.module.ts`);
+    const module = generateModule(table);
+    try {
+      await mkdir(moduleDir, {
+        recursive: true
+      });
+      await mkdir(join(moduleDir, "dtos"), {
+        recursive: true
+      });
+      await writeFile(join(moduleDir, "dtos", `${routePath}.dto.ts`), dto);
+      await writeFile(join(moduleDir, `${routePath}.controller.ts`), controller);
+      await writeFile(join(moduleDir, `${routePath}.service.ts`), service);
+      await writeFile(moduleFilePath, module);
+    } catch (err) {
+      console.error(`\u751F\u6210 Nest.js ${routePath} \u6A21\u5757\u5931\u8D25: ${err.message}`);
+      await rm(moduleDir, {
+        recursive: true
+      });
+    }
+  }
+}
+__name(parseAndGenerateNestResourceTemplate, "parseAndGenerateNestResourceTemplate");
+
 // src/helpers/proxy-error/index.ts
 import fs3 from "fs";
 import path3 from "path";
@@ -885,7 +1552,7 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
   const startTime = Date.now();
   const openapiPath = options.openapiPath || path5.resolve(__dirname, "../client/src/api/gen/openapi.json");
   const serverDir = options.serverDir || path5.resolve(__dirname, "../server");
-  const writeFile = options.writeFile !== false;
+  const writeFile2 = options.writeFile !== false;
   let openapi;
   if (options.openapiData) {
     openapi = JSON.parse(JSON.stringify(options.openapiData));
@@ -896,7 +1563,7 @@ async function enhanceOpenApiWithSourceInfo(options = {}) {
   const controllerFiles = await findControllerFiles(serverDir);
   const sourceMap = await buildSourceMap(controllerFiles, processControllerFile);
   const enhanced = enhanceOpenApiPaths(openapi, sourceMap);
-  if (writeFile) {
+  if (writeFile2) {
     await fs5.writeFile(openapiPath, JSON.stringify(openapi, null, 2) + "\n", "utf-8");
   }
   const duration = Date.now() - startTime;
@@ -1079,7 +1746,7 @@ import express2 from "express";
 
 // src/middlewares/dev-logs/utils.ts
 import { promises as fs7 } from "fs";
-import { isAbsolute, join, relative } from "path";
+import { isAbsolute, join as join2, relative } from "path";
 
 // src/middlewares/dev-logs/helper/path-matcher.ts
 function pathPatternToRegex(pattern) {
@@ -1119,9 +1786,9 @@ __name(normalizePathForMatching, "normalizePathForMatching");
 // src/middlewares/dev-logs/utils.ts
 function resolveLogDir(provided) {
   if (!provided) {
-    return join(process.cwd(), "logs");
+    return join2(process.cwd(), "logs");
   }
-  return isAbsolute(provided) ? provided : join(process.cwd(), provided);
+  return isAbsolute(provided) ? provided : join2(process.cwd(), provided);
 }
 __name(resolveLogDir, "resolveLogDir");
 function getRelativePath(filePath) {
@@ -1180,7 +1847,7 @@ function resolveLogFilePath(baseDir, fileName) {
   if (segments.some((segment) => segment === "..")) {
     throw new Error("Invalid log file path");
   }
-  const resolved = join(baseDir, segments.join("/"));
+  const resolved = join2(baseDir, segments.join("/"));
   const rel = relative(baseDir, resolved);
   if (rel.startsWith("..")) {
     throw new Error("Access to the specified log file is denied");
@@ -1210,7 +1877,7 @@ function serializeError(error) {
 __name(serializeError, "serializeError");
 
 // src/middlewares/dev-logs/controller.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/middlewares/dev-logs/services.ts
 import { createReadStream, promises as fs8 } from "fs";
@@ -1439,7 +2106,7 @@ function handleError(res, error, message = "Failed to read log file") {
 }
 __name(handleError, "handleError");
 function createGetTraceEntriesHandler(logDir) {
-  const appLogPath = join2(logDir, "server.log");
+  const appLogPath = join3(logDir, "server.log");
   return async (req, res) => {
     const traceId = (req.params.traceId || "").trim();
     if (!traceId) {
@@ -1466,7 +2133,7 @@ function createGetTraceEntriesHandler(logDir) {
 }
 __name(createGetTraceEntriesHandler, "createGetTraceEntriesHandler");
 function createGetRecentTracesHandler(logDir) {
-  const traceLogPath = join2(logDir, "trace.log");
+  const traceLogPath = join3(logDir, "trace.log");
   return async (req, res) => {
     const page = parsePositiveInt(req.query.page, 1);
     const pageSize = parseLimit(req.query.pageSize, 10, 100);
@@ -1634,17 +2301,17 @@ __name(createDevLogsMiddleware, "createDevLogsMiddleware");
 import express3 from "express";
 
 // src/middlewares/collect-logs/controller.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import fs10 from "fs";
 
 // src/middlewares/collect-logs/utils.ts
-import { isAbsolute as isAbsolute2, join as join3 } from "path";
+import { isAbsolute as isAbsolute2, join as join4 } from "path";
 import fs9 from "fs";
 function resolveLogDir2(provided) {
   if (!provided) {
-    return join3(process.cwd(), "logs");
+    return join4(process.cwd(), "logs");
   }
-  return isAbsolute2(provided) ? provided : join3(process.cwd(), provided);
+  return isAbsolute2(provided) ? provided : join4(process.cwd(), provided);
 }
 __name(resolveLogDir2, "resolveLogDir");
 function ensureDir(dir) {
@@ -1667,7 +2334,7 @@ __name(serializeError2, "serializeError");
 
 // src/middlewares/collect-logs/controller.ts
 function collectLogsHandler(logDir, fileName) {
-  const filePath = join4(logDir, fileName);
+  const filePath = join5(logDir, fileName);
   ensureDir(logDir);
   return async (req, res) => {
     try {
@@ -1692,7 +2359,7 @@ function collectLogsHandler(logDir, fileName) {
 }
 __name(collectLogsHandler, "collectLogsHandler");
 function collectLogsBatchHandler(logDir, fileName) {
-  const filePath = join4(logDir, fileName);
+  const filePath = join5(logDir, fileName);
   ensureDir(logDir);
   return async (req, res) => {
     try {
@@ -1847,6 +2514,7 @@ export {
   createOpenapiMiddleware,
   handleDevProxyError,
   normalizeBasePath,
+  parseAndGenerateNestResourceTemplate,
   postprocessDrizzleSchema,
   registerMiddlewares
 };