api-core-lib 12.0.76 → 12.0.78

package/dist/cli.cjs

@@ -74,6 +74,74 @@ var import_chalk = __toESM(require("chalk"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
 var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"), 1);
 var import_openapi_types = __toESM(require_dist(), 1);
+
+// src/generator/core/_propToZod.ts
+function _propToZod(prop) {
+  let zodChain;
+  const getMsg = (key) => `{ "message": "validation.${key}" }`;
+  switch (prop.type) {
+    case "string":
+      if (prop.enumName) {
+        zodChain = `z.enum(${prop.enumName})`;
+      } else {
+        zodChain = "z.string()";
+        if (prop.isRequired) {
+          zodChain += `.min(1, ${getMsg("string.nonempty")})`;
+        }
+        if (prop.maxLength !== void 0) zodChain += `.max(${prop.maxLength}, ${getMsg("string.max")})`;
+        if (prop.pattern) zodChain += `.regex(/${prop.pattern}/, ${getMsg("string.regex")})`;
+        if (prop.format === "email") zodChain += `.email(${getMsg("string.email")})`;
+        if (prop.format === "url") zodChain += `.url(${getMsg("string.url")})`;
+        if (prop.format === "uuid") zodChain += `.uuid(${getMsg("string.uuid")})`;
+        if (prop.format === "datetime") zodChain += `.datetime(${getMsg("string.datetime")})`;
+      }
+      break;
+    case "integer":
+      zodChain = `z.number().int(${getMsg("number.integer")})`;
+      if (prop.minimum !== void 0) zodChain += `.min(${prop.minimum}, ${getMsg("number.min")})`;
+      if (prop.maximum !== void 0) zodChain += `.max(${prop.maximum}, ${getMsg("number.max")})`;
+      break;
+    case "number":
+      zodChain = `z.number()`;
+      if (prop.minimum !== void 0) zodChain += `.min(${prop.minimum}, ${getMsg("number.min")})`;
+      if (prop.maximum !== void 0) zodChain += `.max(${prop.maximum}, ${getMsg("number.max")})`;
+      break;
+    case "boolean":
+      zodChain = `z.boolean()`;
+      break;
+    case "array":
+      const itemSchema = prop.items ? _propToZod(prop.items) : "z.any()";
+      zodChain = `z.array(${itemSchema})`;
+      if (prop.minItems !== void 0) zodChain += `.min(${prop.minItems}, ${getMsg("array.min")})`;
+      if (prop.maxItems !== void 0) zodChain += `.max(${prop.maxItems}, ${getMsg("array.max")})`;
+      break;
+    case "object":
+      if (prop.properties && prop.properties.length > 0) {
+        const shape = prop.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
+        zodChain = `z.object({
+${shape}
+})`;
+      } else {
+        zodChain = "z.record(z.unknown())";
+      }
+      break;
+    default:
+      zodChain = "z.any()";
+      break;
+  }
+  if (prop.description) {
+    zodChain += `.describe(${JSON.stringify(prop.description)})`;
+  }
+  if (!prop.isRequired) {
+    zodChain += ".optional()";
+  }
+  if (prop.isNullable) {
+    zodChain += ".nullable()";
+  }
+  return zodChain;
+}
+
+// src/generator/index.ts
 var DEBUG_MODE = process.env.DEBUG === "true";
 var debugLog = (title, data) => DEBUG_MODE && console.log(import_chalk.default.yellow(`
 [DEBUG: ${title}]`), import_util.default.inspect(data, { depth: 5, colors: true }));
@@ -101,6 +169,7 @@ function parseSchema(name, schema, allEnums) {
     for (const propName in schema.properties) {
       const propSchema = schema.properties[propName];
       let itemSchema;
+      let generatedEnumName;
       if (propSchema.type === "array" && propSchema.items) {
         const itemTypeName = `${toPascalCase(name)}${toPascalCase(propName)}Item`;
         itemSchema = parseSchema(itemTypeName, propSchema.items, allEnums).properties[0];
@@ -108,7 +177,10 @@ function parseSchema(name, schema, allEnums) {
       if (propSchema.enum) {
         const enumName = `${toPascalCase(name)}${toPascalCase(propName)}Enum`;
         enums[propName] = propSchema.enum;
-        if (!allEnums.has(enumName)) allEnums.set(enumName, { name: enumName, values: propSchema.enum });
+        if (!allEnums.has(enumName)) {
+          allEnums.set(enumName, { name: enumName, values: propSchema.enum });
+        }
+        generatedEnumName = enumName;
       }
       properties.push({
         name: propName,
@@ -118,9 +190,18 @@ function parseSchema(name, schema, allEnums) {
         description: propSchema.description,
         example: propSchema.example,
         enum: propSchema.enum,
+        enumName: generatedEnumName,
+        // <-- Pass the enum name to the property
         format: propSchema.format,
         items: itemSchema,
-        properties: propSchema.properties ? parseSchema(`${name}${toPascalCase(propName)}`, propSchema, allEnums).properties : void 0
+        properties: propSchema.properties ? parseSchema(`${name}${toPascalCase(propName)}`, propSchema, allEnums).properties : void 0,
+        minLength: propSchema.minLength,
+        maxLength: propSchema.maxLength,
+        pattern: propSchema.pattern,
+        minimum: propSchema.minimum,
+        maximum: propSchema.maximum,
+        minItems: propSchema.minItems,
+        maxItems: propSchema.maxItems
       });
     }
   }
@@ -194,174 +275,50 @@ async function generateModuleFiles(module2, allSchemas, allEnums, outputDir) {
   Generating module: ${import_chalk.default.bold(module2.moduleName)}`));
   const schemasToImport = [...module2.schemas].sort();
   const enumsToImport = [...module2.enums].sort();
-  const indexContent = [`// This file is auto-generated.
+  const indexContent = [`// This file is auto-generated. Do not edit directly.
 
 export * from './config';`];
-  let configContent = `/* eslint-disable */
-// This file is auto-generated.
-
-import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
-`;
-  if (schemasToImport.length > 0) configContent += `import type { ${schemasToImport.join(", ")} } from './types';
-`;
-  const actionsType = Object.values(module2.actions).map((a) => `  ${a.name}: ActionConfigModule<${a.inputType}, ${a.outputType}>;`).join("\n");
-  const actionsValue = Object.values(module2.actions).map((a) => {
-    const { inputType, outputType, name, ...c } = a;
-    return `    ${name}: ${JSON.stringify(c, null, 2).replace(/\n/g, "\n    ")}`;
-  }).join(",\n");
-  configContent += `
-export const ${module2.moduleName}Module: ApiModuleConfig<{
-${actionsType}
-}> = {
-  baseEndpoint: '${module2.baseEndpoint}',
-  actions: {
-${actionsValue}
-  },
-};
-`;
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "config.ts"), configContent.trim());
-  console.log(import_chalk.default.gray(`    \u2713 config.ts`));
   if (schemasToImport.length > 0) {
-    if (enumsToImport.length > 0) {
-      let enumsContent = `// This file is auto-generated.
+    indexContent.push(`export * from './types';`);
+    indexContent.push(`export * from './enums';`);
+    let validationContent = `// This file is auto-generated by the API generator. Do not edit directly.
 
+import { z } from 'zod';
 `;
-      for (const enumName of enumsToImport) {
-        const enumDef = allEnums.get(enumName);
-        if (enumDef) {
-          enumsContent += `export const ${enumName} = ${JSON.stringify(enumDef.values)} as const;
-`;
-          enumsContent += `export type ${enumName} = typeof ${enumName}[number];
-
+    if (enumsToImport.length > 0) {
+      validationContent += `import { ${enumsToImport.join(", ")} } from './enums';
 `;
-        }
-      }
-      import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "enums.ts"), enumsContent);
-      console.log(import_chalk.default.gray(`    \u2713 enums.ts`));
-      indexContent.push(`export * from './enums';`);
     }
-    let typesContent = `// This file is auto-generated.
-
-`;
-    if (enumsToImport.length > 0) typesContent += `import type { ${enumsToImport.join(", ")} } from './enums';
-
-`;
     for (const typeName of schemasToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
-        if (parsedSchema.description) typesContent += `/**
- * ${parsedSchema.description}
- */
+        const zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
+        validationContent += `
+/**
+ * Zod schema for {@link ${typeName}}.
 `;
-        typesContent += `export interface ${typeName} {
-`;
-        for (const prop of parsedSchema.properties) {
-          if (prop.description) typesContent += `  /**
-   * ${prop.description}
-${prop.example ? `   * @example ${JSON.stringify(prop.example)}
-` : ""}   */
-`;
-          let propType = prop.type;
-          if (prop.enum) propType = `${toPascalCase(typeName)}${toPascalCase(prop.name)}Enum`;
-          else if (prop.items) propType = prop.items.name ? `${toPascalCase(prop.items.name)}[]` : `${prop.items.type || "unknown"}[]`;
-          else if (prop.type === "object") propType = prop.properties && prop.properties.length > 0 ? `Record<string, unknown>` : `Record<string, unknown>`;
-          typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
+        if (parsedSchema.description) {
+          validationContent += ` * @description ${parsedSchema.description.replace(/\*\//g, "*\\/")}
 `;
         }
-        typesContent += `}
-
+        validationContent += ` */
 `;
-      }
-    }
-    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "types.ts"), typesContent);
-    console.log(import_chalk.default.gray(`    \u2713 types.ts`));
-    indexContent.push(`export * from './types';`);
-    let validationContent = "";
-    if (schemasToImport.length > 0) {
-      const firstSchemaName = schemasToImport[0];
-      validationContent = `
-// =============================================================================
-// III. \u0645\u062B\u0627\u0644 \u0639\u0644\u0649 \u0643\u064A\u0641\u064A\u0629 \u0627\u0633\u062A\u062E\u062F\u0627\u0645 \u0627\u0644\u0645\u062E\u0637\u0637 \u0641\u064A \u0627\u0644\u0643\u0648\u062F
-// =============================================================================
-/*
-function
- 
-validate${firstSchemaName}(data: unknown) {
-  try {
-    const validatedData = ${firstSchemaName}Schema.parse(data);
-    console.log("\u2705 Validation successful:", validatedData);
-    return { success: true, data: validatedData };
-  } catch (error) {
-    if (error instanceof ZodError) {
-      console.error("\u274C Validation failed:");
-      // .format() is great for getting a structured error object
-      console.log(JSON.stringify(error.format(), null, 2));
-      return { success: false, errors: error.format() };
-    }
-    throw error; // Rethrow other unexpected errors
-  }
-}
+        validationContent += `export const ${typeName}Schema = z.object({
+${zodShape}
+});
 
-// Example usage with invalid data:
-const invalidData = { /* ... \u0628\u064A\u0627\u0646\u0627\u062A \u063A\u064A\u0631 \u0643\u0627\u0645\u0644\u0629 \u0623\u0648 \u062E\u0627\u0637\u0626\u0629 ... */ };
-// validate${firstSchemaName}(invalidData);
-*/
 `;
-    }
-    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent);
-    console.log(import_chalk.default.gray(`    \u2713 validation.ts (with integrated usage example)`));
-    indexContent.push(`export * from './validation';`);
-    let mocksContent = `// This file is auto-generated.
-import type { ${schemasToImport.join(", ")} } from './types';
-`;
-    if (enumsToImport.length > 0) mocksContent += `import { ${enumsToImport.join(", ")} } from './enums';
-
-`;
-    for (const typeName of schemasToImport) {
-      const parsedSchema = allSchemas.get(typeName);
-      if (parsedSchema) {
-        let mockObject = {};
-        parsedSchema.properties.forEach((p) => {
-          mockObject[p.name] = _propToMock(p);
-        });
-        mocksContent += `export const mock${typeName}: ${typeName} = ${JSON.stringify(mockObject, null, 2)};
-
+        validationContent += `export type ${typeName}Validated = z.infer<typeof ${typeName}Schema>;
 `;
       }
     }
-    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "mocks.ts"), mocksContent);
-    console.log(import_chalk.default.gray(`    \u2713 mocks.ts`));
-    indexContent.push(`export * from './mocks';`);
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent);
+    console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
+    indexContent.push(`export * from './validation';`);
   }
   import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "index.ts"), indexContent.join("\n"));
   console.log(import_chalk.default.gray(`    \u2713 index.ts`));
 }
-function _propToMock(prop) {
-  if (prop.example) return prop.example;
-  if (prop.name.match(/image|avatar|logo|url/i)) return "https://via.placeholder.com/150";
-  if (prop.enum) return prop.enum[0];
-  switch (prop.type) {
-    case "string":
-      if (prop.format === "email") return "test@example.com";
-      if (prop.format === "uuid") return "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
-      return `Mock ${toPascalCase(prop.name)}`;
-    case "integer":
-    case "number":
-      return 1;
-    case "boolean":
-      return true;
-    case "array":
-      return prop.items ? [_propToMock(prop.items)] : [];
-    case "object":
-      const mock = {};
-      if (prop.properties) prop.properties.forEach((p) => {
-        mock[p.name] = _propToMock(p);
-      });
-      return mock;
-    default:
-      return null;
-  }
-}
 async function runGenerator(options) {
   console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Sapphire Edition)..."));
   import_dotenv.default.config({ path: options.envPath });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.76",
+  "version": "12.0.78",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {