@sgrgv/swagger-zod 1.0.0

package/index.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+
+const args = process.argv.slice(2);
+const swaggerUrl = args[0];
+const endpoint = args[1];
+
+console.log(`📥 Скачиваю спецификацию из: ${swaggerUrl}`);
+
+function getZodTypeFromSchema(schema, schemas, isResponse = false) {
+  if (!schema) return 'z.unknown()';
+  
+  const isNullable = schema.nullable === true;
+  let zodType;
+  
+  if (schema.type === 'string') {
+    if (schema.format === 'date-time') {
+      zodType = 'z.iso.datetime({ offset: true })';
+    } else {
+      zodType = 'z.string()';
+    }
+  } else if (schema.type === 'integer') {
+    zodType = 'z.number().int()';
+  } else if (schema.type === 'number') {
+    zodType = 'z.number()';
+  } else if (schema.type === 'boolean') {
+    zodType = 'z.boolean()';
+  } else if (schema.type === 'array') {
+    const itemType = getZodTypeFromSchema(schema.items, schemas, isResponse);
+    zodType = `z.array(${itemType})`;
+  } else if (schema.type === 'object' && schema.properties) {
+    const props = [];
+    const requiredFields = schema.required || [];
+    
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const isRequired = requiredFields.includes(key);
+      const propType = getZodTypeFromSchema(prop, schemas, isResponse);
+      const keyName = /[^a-zA-Z0-9_]/.test(key) ? `"${key}"` : key;
+      
+      // Для response не добавляем .optional()
+      // Для body добавляем .optional() только если поле не в required
+      if (isResponse) {
+        props.push(`    ${keyName}: ${propType}`);
+      } else {
+        props.push(`    ${keyName}: ${propType}${isRequired ? '' : '.optional()'}`);
+      }
+    }
+    zodType = `z.object({\n${props.join(',\n')}\n  })`;
+  } else if (schema.$ref) {
+    const refName = schema.$ref.split('/').pop();
+    const refSchema = schemas[refName];
+    if (refSchema) {
+      zodType = getZodTypeFromSchema(refSchema, schemas, isResponse);
+    } else {
+      zodType = 'z.unknown()';
+    }
+  } else {
+    zodType = 'z.unknown()';
+  }
+  
+  if (isNullable) {
+    return `${zodType}.nullable()`;
+  }
+  return zodType;
+}
+
+function getParameterZodType(schema) {
+  if (!schema) return 'z.string()';
+  
+  if (schema.type === 'string') {
+    if (schema.format === 'date-time') {
+      return 'z.iso.datetime({ offset: true })';
+    }
+    return 'z.string()';
+  }
+  if (schema.type === 'integer') return 'z.number().int()';
+  if (schema.type === 'number') return 'z.number()';
+  if (schema.type === 'boolean') return 'z.boolean()';
+  return 'z.string()';
+}
+
+function getTypeFromSchema(schema, schemas) {
+  if (!schema) return 'unknown';
+  
+  const isNullable = schema.nullable === true;
+  let type;
+  
+  if (schema.type === 'string') {
+    type = 'string';
+  } else if (schema.type === 'integer') {
+    type = 'number';
+  } else if (schema.type === 'boolean') {
+    type = 'boolean';
+  } else if (schema.type === 'array') {
+    const itemType = getTypeFromSchema(schema.items, schemas);
+    type = `Array<${itemType}>`;
+  } else if (schema.type === 'object' && schema.properties) {
+    const props = [];
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const optional = !schema.required?.includes(key) ? '?' : '';
+      const propType = getTypeFromSchema(prop, schemas);
+      const keyName = /[^a-zA-Z0-9_]/.test(key) ? `"${key}"` : key;
+      props.push(`  ${keyName}${optional}: ${propType};`);
+    }
+    type = `{\n${props.join('\n')}\n}`;
+  } else if (schema.$ref) {
+    const refName = schema.$ref.split('/').pop();
+    const refSchema = schemas[refName];
+    if (refSchema) {
+      type = getTypeFromSchema(refSchema, schemas);
+    } else {
+      type = 'any';
+    }
+  } else {
+    type = 'any';
+  }
+  
+  if (isNullable && type !== 'unknown') {
+    return `${type} | null`;
+  }
+  return type;
+}
+
+try {
+  const response = await axios.get(swaggerUrl);
+  const spec = response.data;
+  const schemas = spec.components?.schemas || {};
+  
+  const pathItem = spec.paths[endpoint];
+  if (!pathItem) {
+    console.log(`❌ Эндпоинт ${endpoint} не найден`);
+    process.exit(1);
+  }
+  
+  const operation = pathItem.get || pathItem.post;
+  if (!operation) {
+    console.log(`❌ Метод для ${endpoint} не найден`);
+    process.exit(1);
+  }
+  
+  const parameters = operation.parameters || [];
+  const queryParams = parameters.filter(p => p.in === 'query');
+  const headerParams = parameters.filter(p => p.in === 'header');
+  const bodyParam = operation.requestBody;
+  
+  const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema;
+  const responseType = getTypeFromSchema(responseSchema, schemas);
+  const responseZodType = getZodTypeFromSchema(responseSchema, schemas, true); // isResponse = true
+  
+  const bodyType = bodyParam?.content?.['application/json']?.schema;
+  const bodyTypeStr = bodyType ? getTypeFromSchema(bodyType, schemas) : null;
+  const bodyZodType = bodyType ? getZodTypeFromSchema(bodyType, schemas, false) : null; // isResponse = false
+  
+  const typeName = endpoint.replace(/\//g, '_').slice(1);
+  
+  let code = `/**
+ * Типы и Zod схема для эндпоинта: ${endpoint}
+ */
+
+import { z } from 'zod';
+
+`;
+  
+  // Query параметры (всегда optional)
+  if (queryParams.length > 0) {
+    code += `export const QueryParamsSchema = z.object({\n`;
+    queryParams.forEach(p => {
+      const paramType = getParameterZodType(p.schema);
+      const isRequired = p.required === true;
+      const keyName = /[^a-zA-Z0-9_]/.test(p.name) ? `"${p.name}"` : p.name;
+      code += `  ${keyName}: ${paramType}${isRequired ? '' : '.optional()'},\n`;
+    });
+    code += `});\n\n`;
+    code += `export type QueryParams = z.infer<typeof QueryParamsSchema>;\n\n`;
+  }
+  
+  // Header параметры (всегда optional)
+  if (headerParams.length > 0) {
+    code += `export const HeaderParamsSchema = z.object({\n`;
+    headerParams.forEach(p => {
+      const paramType = getParameterZodType(p.schema);
+      const isRequired = p.required === true;
+      const keyName = /[^a-zA-Z0-9_]/.test(p.name) ? `"${p.name}"` : p.name;
+      code += `  ${keyName}: ${paramType}${isRequired ? '' : '.optional()'},\n`;
+    });
+    code += `});\n\n`;
+    code += `export type HeaderParams = z.infer<typeof HeaderParamsSchema>;\n\n`;
+  }
+  
+  // Body (optional только если поле не в required)
+  if (bodyZodType) {
+    code += `export const BodySchema = ${bodyZodType};\n\n`;
+    code += `export type Body = z.infer<typeof BodySchema>;\n\n`;
+  }
+  
+  // Response (НИКОГДА не добавляем optional)
+  code += `export const ResponseSchema = ${responseZodType};\n\n`;
+  code += `export type Response = z.infer<typeof ResponseSchema>;\n`;
+  
+  const outputFile = path.join(process.cwd(), `${typeName}.zod.ts`);
+  fs.writeFileSync(outputFile, code);
+  console.log(`✅ Создан ${typeName}.zod.ts`);
+  
+} catch (error) {
+  console.error('❌ Ошибка:', error.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@sgrgv/swagger-zod",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "swagger-zod": "./index.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.6"
+  }
+}