api-core-lib 12.0.66 → 12.0.68

package/dist/cli.cjs

@@ -69,17 +69,82 @@ var import_path2 = __toESM(require("path"), 1);
 // src/generator/index.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
+var import_util = __toESM(require("util"), 1);
 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);
-var import_json_schema_to_typescript = require("json-schema-to-typescript");
+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: 4, colors: true }));
+var toPascalCase = (str) => str.replace(/[^a-zA-Z0-9_]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
+var toCamelCase = (str) => {
+  const s = toPascalCase(str);
+  return s.charAt(0).toLowerCase() + s.slice(1);
+};
+var getModuleName = (opId) => `${opId.split("_")[0].replace(/Controller$/, "")}Api`;
+var getActionName = (opId) => toCamelCase(opId.split("_")[1] || opId);
+var findCommonPath = (paths) => {
+  if (!paths || paths.length === 0) return "/";
+  const sorted = [...paths].sort();
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  let i = 0;
+  while (i < first.length && first.charAt(i) === last.charAt(i)) i++;
+  const prefix = first.substring(0, i);
+  return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
+};
+var generateFriendlyMessage = (fieldName, validation) => {
+  const friendlyName = fieldName.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
+  switch (validation) {
+    case "required":
+      return `${friendlyName} is required.`;
+    case "email":
+      return `Please enter a valid email for ${friendlyName}.`;
+    default:
+      return `Invalid value for ${friendlyName}.`;
+  }
+};
+function parseSchema(name, schema) {
+  const properties = [];
+  if (schema.properties) {
+    for (const propName in schema.properties) {
+      const propSchema = schema.properties[propName];
+      let items = void 0;
+      if (propSchema.type === "array" && propSchema.items) {
+        items = parseSchema("item", propSchema.items).properties[0];
+      }
+      properties.push({
+        name: propName,
+        type: propSchema.type || "object",
+        isRequired: (schema.required || []).includes(propName),
+        isNullable: propSchema.nullable || false,
+        description: propSchema.description,
+        example: propSchema.example,
+        enum: propSchema.enum,
+        format: propSchema.format,
+        items,
+        // نستخدم المتغير الذي تم حسابه بأمان
+        properties: propSchema.properties ? parseSchema("sub-object", propSchema).properties : void 0
+      });
+    }
+  }
+  return { name, description: schema.description, properties };
+}
 function parseSpecToModules(spec) {
-  const modules = {};
-  const modulePaths = {};
-  if (!spec.components) spec.components = {};
-  if (!spec.components.schemas) spec.components.schemas = {};
-  const allSchemas = spec.components.schemas;
+  const modules = /* @__PURE__ */ new Map();
+  const allSchemas = /* @__PURE__ */ new Map();
+  const modulePaths = /* @__PURE__ */ new Map();
+  const registerSchema = (schema, baseName) => {
+    if (!schema) return "unknown";
+    if (schema.type === "array" && schema.items) return `${registerSchema(schema.items, `${baseName}Item`)}[]`;
+    if (schema.type === "object" || schema.properties || schema.allOf || !schema.type) {
+      const typeName = toPascalCase(baseName.replace(/_v\d+(Request|Response)$/, "$1"));
+      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema));
+      return typeName;
+    }
+    return schema.type === "integer" ? "number" : schema.type || "unknown";
+  };
   for (const apiPath in spec.paths) {
     const pathItem = spec.paths[apiPath];
     if (!pathItem) continue;
@@ -87,206 +152,230 @@ function parseSpecToModules(spec) {
       if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
       const endpoint = pathItem[method];
       if (!endpoint.operationId) continue;
-      const moduleName = _getModuleNameFromOperationId(endpoint.operationId);
-      if (!modules[moduleName]) {
-        modules[moduleName] = { baseEndpoint: "", actions: {}, types: /* @__PURE__ */ new Set() };
-        modulePaths[moduleName] = [];
+      const moduleName = getModuleName(endpoint.operationId);
+      if (!modules.has(moduleName)) {
+        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set() });
+        modulePaths.set(moduleName, []);
       }
-      modulePaths[moduleName].push(apiPath);
-      const { inputType, outputType } = _extractInputOutputTypes(endpoint, allSchemas);
+      const currentModule = modules.get(moduleName);
+      modulePaths.get(moduleName).push(apiPath);
+      const successKey = Object.keys(endpoint.responses).find((c) => c.startsWith("2"));
+      const successRes = successKey ? endpoint.responses[successKey] : void 0;
+      const outputType = successKey === "204" ? "void" : registerSchema(successRes?.content?.["application/json"]?.schema, `${endpoint.operationId}Response`);
+      const reqBody = endpoint.requestBody;
+      let inputType = "undefined";
+      if (reqBody?.content?.["application/json"]?.schema) inputType = registerSchema(reqBody.content["application/json"].schema, `${endpoint.operationId}Request`);
+      else if ((endpoint.parameters || []).some((p) => p.in === "query")) inputType = "QueryOptions";
       [inputType, outputType].forEach((t) => {
-        if (t && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(t)) {
-          modules[moduleName].types.add(t.replace("[]", ""));
+        const cleanType = t.replace("[]", "");
+        if (cleanType && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(cleanType)) {
+          currentModule.schemas.add(cleanType);
         }
       });
-      const actionName = _sanitizeActionName(endpoint.operationId);
-      modules[moduleName].actions[actionName] = {
-        method: method.toUpperCase(),
-        path: apiPath,
-        // سنقوم بتعديل هذا لاحقًا ليصبح نسبيًا
-        description: endpoint.summary || "",
-        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
-        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
-        invalidates: [],
-        _inputType: inputType,
-        _outputType: outputType
-      };
+      const actionName = getActionName(endpoint.operationId);
+      currentModule.actions[actionName] = { name: actionName, method: method.toUpperCase(), path: apiPath, description: endpoint.summary || "", hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"), autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"), requiresAuth: !!endpoint.security && endpoint.security.length > 0, inputType, outputType };
     }
   }
-  for (const moduleName in modules) {
-    const basePath = _findCommonBasePath(modulePaths[moduleName]);
-    modules[moduleName].baseEndpoint = basePath;
-    for (const actionName in modules[moduleName].actions) {
-      const action = modules[moduleName].actions[actionName];
+  modules.forEach((mod, name) => {
+    const basePath = findCommonPath(modulePaths.get(name));
+    mod.baseEndpoint = basePath;
+    Object.values(mod.actions).forEach((action) => {
       const relativePath = action.path.replace(basePath, "").replace(/^\//, "");
       action.path = relativePath === "" ? "/" : relativePath;
-    }
-  }
-  return modules;
-}
-function _extractInputOutputTypes(endpoint, schemas) {
-  const operationId = endpoint.operationId || "UnnamedOperation";
-  const successResponseKey = Object.keys(endpoint.responses).find((code) => code.startsWith("2"));
-  const successResponse = successResponseKey ? endpoint.responses[successResponseKey] : void 0;
-  const responseSchema = successResponse?.content?.["application/json"]?.schema;
-  const outputType = successResponseKey === "204" ? "void" : _schemaToTypeName(responseSchema, `${operationId}Response`, schemas);
-  const requestBody = endpoint.requestBody;
-  const requestSchema = requestBody?.content?.["application/json"]?.schema;
-  let inputType = "undefined";
-  if (requestSchema) {
-    inputType = _schemaToTypeName(requestSchema, `${operationId}Request`, schemas);
-  } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
-    inputType = "QueryOptions";
-  }
-  return { inputType, outputType };
+    });
+  });
+  debugLog("Final Parsed Modules", Object.fromEntries(modules));
+  return { modules, allSchemas };
 }
-function _schemaToTypeName(schema, name, schemas) {
-  if (!schema) return "unknown";
-  if (schema.type === "array" && schema.items) {
-    const itemTypeName = _schemaToTypeName(schema.items, `${name}Item`, schemas);
-    return `${itemTypeName}[]`;
-  }
-  if (schema.type === "object" || schema.properties || schema.allOf) {
-    const typeName = _toPascalCase(name);
-    if (!schemas[typeName]) {
-      schemas[typeName] = schema;
-    }
-    return typeName;
-  }
-  if (schema.type && ["string", "number", "boolean", "integer"].includes(schema.type)) {
-    return schema.type === "integer" ? "number" : schema.type;
-  }
-  if (Object.keys(schema).length === 0) {
-    const typeName = _toPascalCase(name);
-    if (!schemas[typeName]) {
-      schemas[typeName] = { type: "object", properties: {}, description: "Represents a dynamic or empty object." };
+async function generateModuleFiles(module2, allSchemas, outputDir) {
+  const moduleOutputPath = import_path.default.join(outputDir, module2.moduleName);
+  if (!import_fs.default.existsSync(moduleOutputPath)) import_fs.default.mkdirSync(moduleOutputPath, { recursive: true });
+  console.log(import_chalk.default.cyan(`
+  Generating module: ${import_chalk.default.bold(module2.moduleName)}`));
+  const typesToImport = [...module2.schemas].sort();
+  let configContent = `/* eslint-disable */
+// This file is auto-generated.
+
+import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
+`;
+  if (typesToImport.length > 0) configContent += `import type { ${typesToImport.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`));
+  const indexContent = [`// This file is auto-generated.
+
+export * from './config';`];
+  if (typesToImport.length > 0) {
+    let typesContent = `// This file is auto-generated.
+
+`;
+    for (const typeName of typesToImport) {
+      const parsedSchema = allSchemas.get(typeName);
+      if (parsedSchema) {
+        if (parsedSchema.description) typesContent += `/**
+ * ${parsedSchema.description}
+ */
+`;
+        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 = prop.enum.map((e) => typeof e === "string" ? `'${e}'` : e).join(" | ");
+          else if (prop.items) propType = `${toPascalCase(prop.items.name)}[]`;
+          typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
+`;
+        }
+        typesContent += `}
+
+`;
+      }
     }
-    return typeName;
-  }
-  return "unknown";
-}
-async function generateModuleFiles(moduleName, moduleData, allSchemas, outputDir) {
-  console.log(import_chalk.default.gray(`  Generating files for module: ${import_chalk.default.bold(moduleName)}...`));
-  const moduleFolderPath = import_path.default.join(outputDir, moduleName);
-  if (!import_fs.default.existsSync(moduleFolderPath)) import_fs.default.mkdirSync(moduleFolderPath, { recursive: true });
-  await _generateTypesFile(moduleFolderPath, moduleName, moduleData.types, allSchemas);
-  await _generateConfigFile(moduleFolderPath, moduleName, moduleData);
-}
-async function _generateTypesFile(moduleFolderPath, moduleName, typeNames, allSchemas) {
-  if (typeNames.size === 0) {
-    console.log(import_chalk.default.yellow(`    - No types for module "${moduleName}". Skipping types.ts.`));
-    return;
-  }
-  console.log(import_chalk.default.gray(`    - Generating types.ts with ${typeNames.size} types...`));
-  let typesContent = `// This file is auto-generated by the API generator. Do not edit.
+    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 = `// This file is auto-generated.
+import { z } from 'zod';
+
+`;
+    for (const typeName of typesToImport) {
+      const parsedSchema = allSchemas.get(typeName);
+      if (parsedSchema) {
+        let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
+        validationContent += `export const ${typeName}Schema = z.object({
+${zodShape}
+});
 
 `;
-  const compilationOptions = {
-    bannerComment: "",
-    style: { bracketSpacing: true, printWidth: 120, semi: true, singleQuote: true, tabWidth: 2, trailingComma: "es5", useTabs: false },
-    additionalProperties: false
-  };
-  for (const typeName of Array.from(typeNames).sort()) {
-    const schema = allSchemas[typeName];
-    if (schema) {
-      try {
-        const tsType = await (0, import_json_schema_to_typescript.compile)(schema, typeName, compilationOptions);
-        typesContent += tsType + "\n";
-      } catch (compileError) {
-        console.error(import_chalk.default.red(`    - Error compiling type "${typeName}": ${compileError.message}`));
       }
-    } else {
-      console.log(import_chalk.default.yellow(`    - Warning: Schema for type "${typeName}" not found.`));
     }
-  }
-  const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
-  import_fs.default.writeFileSync(typesFilePath, typesContent, { encoding: "utf-8" });
-}
-async function _generateConfigFile(moduleFolderPath, moduleName, moduleData) {
-  const actionsCount = Object.keys(moduleData.actions).length;
-  console.log(import_chalk.default.gray(`    - Generating config.ts with ${actionsCount} actions...`));
-  const typeNamesArray = [...moduleData.types].sort();
-  const typesImportStatement = typeNamesArray.length > 0 ? `import type { ${typeNamesArray.join(", ")} } from './types';` : ``;
-  const actionsTypeParts = Object.entries(moduleData.actions).map(
-    ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType}, ${actionData._outputType}>;`
-  );
-  const actionsTypeDefinition = `{
-${actionsTypeParts.join("\n")}
-}`;
-  const actionsValueParts = Object.entries(moduleData.actions).map(([actionName, actionData]) => {
-    const { _inputType, _outputType, ...config } = actionData;
-    return `    ${actionName}: ${JSON.stringify(config, null, 2).replace(/\n/g, "\n    ")}`;
-  });
-  const actionsValueDefinition = `{
-${actionsValueParts.join(",\n")}
-  }`;
-  const configContent = `/* eslint-disable */
-// This file is auto-generated...
+    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';`);
+    let mocksContent = `// This file is auto-generated.
+import type { ${typesToImport.join(", ")} } from './types';
 
-import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
-${typesImportStatement}
+`;
+    for (const typeName of typesToImport) {
+      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)};
 
-export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
-  baseEndpoint: '${moduleData.baseEndpoint}',
-  actions: ${actionsValueDefinition},
-};
 `;
-  const configFilePath = import_path.default.join(moduleFolderPath, "config.ts");
-  import_fs.default.writeFileSync(configFilePath, configContent.trim(), { encoding: "utf-8" });
-}
-function _toPascalCase(str) {
-  return str.replace(/[^a-zA-Z0-9]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
-}
-function _getModuleNameFromOperationId(operationId) {
-  const controllerName = operationId.split("_")[0].replace(/Controller$/, "");
-  return `${controllerName}Api`;
+      }
+    }
+    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, "index.ts"), indexContent.join("\n"));
+  console.log(import_chalk.default.gray(`    \u2713 index.ts`));
 }
-function _sanitizeActionName(operationId) {
-  const nameParts = operationId.split("_");
-  if (nameParts.length <= 1) return operationId;
-  const actionPart = nameParts[1];
-  return actionPart.charAt(0).toLowerCase() + actionPart.slice(1);
+function _propToZod(prop) {
+  let zodString = "z.any()";
+  const requiredMsg = { required_error: prop.description || generateFriendlyMessage(prop.name, "required") };
+  switch (prop.type) {
+    case "string":
+      zodString = `z.string(${JSON.stringify(requiredMsg)})`;
+      if (prop.format === "email") zodString += `.email({ message: "${generateFriendlyMessage(prop.name, "email")}" })`;
+      if (prop.format === "uuid") zodString += `.uuid()`;
+      if (prop.enum) zodString = `z.enum(${JSON.stringify(prop.enum)}, ${JSON.stringify(requiredMsg)})`;
+      break;
+    case "integer":
+    case "number":
+      zodString = `z.number(${JSON.stringify(requiredMsg)})`;
+      break;
+    case "boolean":
+      zodString = `z.boolean(${JSON.stringify(requiredMsg)})`;
+      break;
+    case "array":
+      zodString = `z.array(${prop.items ? _propToZod(prop.items) : "z.any()"})`;
+      break;
+    case "object":
+      let shape = "z.any()";
+      if (prop.properties) shape = `z.object({
+${prop.properties.map((p) => `    ${p.name}: ${_propToZod(p)}`).join(",\n")}
+  })`;
+      zodString = shape;
+      break;
+  }
+  if (!prop.isRequired) zodString += ".optional()";
+  if (prop.isNullable) zodString += ".nullable()";
+  return zodString;
 }
-function _findCommonBasePath(paths) {
-  if (!paths || paths.length === 0) return "/";
-  const sortedPaths = [...paths].sort();
-  const first = sortedPaths[0];
-  const last = sortedPaths[sortedPaths.length - 1];
-  let i = 0;
-  while (i < first.length && first.charAt(i) === last.charAt(i)) {
-    i++;
+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;
   }
-  let prefix = first.substring(0, i);
-  return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
 }
 async function runGenerator(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Core Lib Code Generator..."));
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Phoenix Edition)..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
-  console.log(import_chalk.default.blue("\u2713 Step 1: Environment variables loaded."));
   try {
     console.log(import_chalk.default.blue(`
-\u23F3 Step 2: Fetching and fully dereferencing spec from ${specUrl}...`));
-    const dereferencedSpec = await import_swagger_parser.default.dereference(specUrl);
-    console.log(import_chalk.default.green("\u2713 Spec fetched and fully dereferenced successfully."));
-    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Parsing spec using intelligent grouping..."));
-    const modules = parseSpecToModules(dereferencedSpec);
-    const modulesCount = Object.keys(modules).length;
-    console.log(import_chalk.default.green(`\u2713 Found and grouped ${modulesCount} logical modules.`));
-    console.log(import_chalk.default.blue("\n\u23F3 Step 4: Generating module files..."));
-    const modulesOutputPath = import_path.default.join(options.output, "modules");
-    const allSchemas = dereferencedSpec.components?.schemas || {};
-    for (const moduleName in modules) {
-      const moduleData = modules[moduleName];
-      await generateModuleFiles(moduleName, moduleData, allSchemas, modulesOutputPath);
+\u23F3 Step 1: Dereferencing spec from ${specUrl}...`));
+    const spec = await import_swagger_parser.default.dereference(specUrl);
+    console.log(import_chalk.default.green("\u2713 Spec fully dereferenced."));
+    debugLog("Dereferenced Spec", spec);
+    console.log(import_chalk.default.blue("\n\u23F3 Step 2: Parsing spec with intelligent grouping..."));
+    const { modules, allSchemas } = parseSpecToModules(spec);
+    console.log(import_chalk.default.green(`\u2713 Found and grouped ${modules.size} logical modules.`));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Generating all module files..."));
+    for (const module2 of modules.values()) {
+      await generateModuleFiles(module2, allSchemas, options.output);
     }
-    console.log(import_chalk.default.green("\u2713 All module files generated."));
-    console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete!"));
+    console.log(import_chalk.default.green("\n\u2713 All module files generated successfully."));
+    console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete! Your development platform is ready."));
     console.log(import_chalk.default.bold.cyan(`   Output directory: ${options.output}`));
   } catch (error) {
     console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));
     console.error(import_chalk.default.red(`Error Message: ${error.message}`));
-    if (error.stack) console.error(import_chalk.default.gray(error.stack));
+    if (error.stack && DEBUG_MODE) console.error(import_chalk.default.gray(error.stack));
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.66",
+  "version": "12.0.68",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {
@@ -42,24 +42,27 @@
     "chalk": "^4.1.2",
     "colorette": "^2.0.20",
     "commander": "^9.4.1",
-    "dotenv": "^16.0.3",
+    "dotenv": "^16.6.1",
     "fast-deep-equal": "^3.1.3",
     "fs-extra": "^11.3.1",
     "json-schema-to-typescript": "^15.0.4",
     "openapi-typescript": "^6.2.4",
     "openapi-typescript-codegen": "^0.29.0",
     "path": "^0.12.7",
-    "uuid": "^9.0.1"
+    "swagger-parser": "^10.0.3",
+    "uuid": "^9.0.1",
+    "zod": "^4.1.5"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.23.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.2.1",
+    "@types/node": "^24.3.0",
     "@types/react": "^18.3.2",
     "@types/uuid": "^9.0.8",
     "javascript-obfuscator": "^4.1.1",
     "jest": "^30.0.5",
+    "openapi-types": "^12.1.3",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "ts-jest": "^29.4.1",