api-core-lib 12.0.68 → 12.0.69

package/dist/cli.cjs

@@ -76,7 +76,7 @@ var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"), 1);
 var import_openapi_types = __toESM(require_dist(), 1);
 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 }));
+[DEBUG: ${title}]`), import_util.default.inspect(data, { depth, 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);
@@ -96,23 +96,18 @@ var findCommonPath = (paths) => {
 };
 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}.`;
-  }
+  return `${friendlyName} is required.`;
 };
-function parseSchema(name, schema) {
+function parseSchema(name, schema, allEnums) {
   const properties = [];
+  const enums = {};
   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];
+      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 });
       }
       properties.push({
         name: propName,
@@ -123,24 +118,24 @@ function parseSchema(name, schema) {
         example: propSchema.example,
         enum: propSchema.enum,
         format: propSchema.format,
-        items,
-        // نستخدم المتغير الذي تم حسابه بأمان
-        properties: propSchema.properties ? parseSchema("sub-object", propSchema).properties : void 0
+        items: propSchema.type === "array" && propSchema.items ? parseSchema(`${name}${toPascalCase(propName)}Item`, propSchema.items, allEnums).properties[0] : void 0,
+        properties: propSchema.properties ? parseSchema(`${name}${toPascalCase(propName)}`, propSchema, allEnums).properties : void 0
       });
     }
   }
-  return { name, description: schema.description, properties };
+  return { name, description: schema.description, properties, enums };
 }
 function parseSpecToModules(spec) {
   const modules = /* @__PURE__ */ new Map();
   const allSchemas = /* @__PURE__ */ new Map();
+  const allEnums = /* @__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));
+      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema, allEnums));
       return typeName;
     }
     return schema.type === "integer" ? "number" : schema.type || "unknown";
@@ -154,7 +149,7 @@ function parseSpecToModules(spec) {
       if (!endpoint.operationId) continue;
       const moduleName = getModuleName(endpoint.operationId);
       if (!modules.has(moduleName)) {
-        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set() });
+        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set(), enums: /* @__PURE__ */ new Set() });
         modulePaths.set(moduleName, []);
       }
       const currentModule = modules.get(moduleName);
@@ -170,35 +165,33 @@ function parseSpecToModules(spec) {
         const cleanType = t.replace("[]", "");
         if (cleanType && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(cleanType)) {
           currentModule.schemas.add(cleanType);
+          const schemaDef = allSchemas.get(cleanType);
+          if (schemaDef) Object.keys(schemaDef.enums).forEach((propName) => currentModule.enums.add(`${toPascalCase(cleanType)}${toPascalCase(propName)}Enum`));
         }
       });
-      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 };
+      currentModule.actions[getActionName(endpoint.operationId)] = { name: getActionName(endpoint.operationId), 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 };
     }
   }
   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;
-    });
+    mod.baseEndpoint = findCommonPath(modulePaths.get(name));
+    Object.values(mod.actions).forEach((action) => action.path = action.path.replace(mod.baseEndpoint, "").replace(/^\//, "") || "/");
   });
   debugLog("Final Parsed Modules", Object.fromEntries(modules));
-  return { modules, allSchemas };
+  return { modules, allSchemas, allEnums };
 }
-async function generateModuleFiles(module2, allSchemas, outputDir) {
+async function generateModuleFiles(module2, allSchemas, allEnums, 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();
+  const schemasToImport = [...module2.schemas].sort();
+  const enumsToImport = [...module2.enums].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';
+  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) => {
@@ -220,11 +213,32 @@ ${actionsValue}
   const indexContent = [`// This file is auto-generated.
 
 export * from './config';`];
-  if (typesToImport.length > 0) {
+  if (schemasToImport.length > 0) {
+    if (enumsToImport.length > 0) {
+      let enumsContent = `// This file is auto-generated.
+
+`;
+      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];
+
+`;
+        }
+      }
+      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.
 
 `;
-    for (const typeName of typesToImport) {
+    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 += `/**
@@ -240,8 +254,9 @@ ${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)}[]`;
+          if (prop.enum) propType = `${toPascalCase(typeName)}${toPascalCase(prop.name)}Enum`;
+          else if (prop.items) propType = prop.items.properties ? `${toPascalCase(`${typeName}${toPascalCase(prop.name)}Item`)}[]` : `${prop.items.type}[]`;
+          else if (prop.properties) propType = `Record<string, unknown>`;
           typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
 `;
         }
@@ -255,12 +270,14 @@ ${prop.example ? `   * @example ${JSON.stringify(prop.example)}
     indexContent.push(`export * from './types';`);
     let validationContent = `// This file is auto-generated.
 import { z } from 'zod';
+`;
+    if (enumsToImport.length > 0) validationContent += `import { ${enumsToImport.join(", ")} } from './enums';
 
 `;
-    for (const typeName of typesToImport) {
+    for (const typeName of schemasToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
-        let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
+        let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p, typeName)}`).join(",\n");
         validationContent += `export const ${typeName}Schema = z.object({
 ${zodShape}
 });
@@ -272,10 +289,12 @@ ${zodShape}
     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 { ${schemasToImport.join(", ")} } from './types';
+`;
+    if (enumsToImport.length > 0) mocksContent += `import { ${enumsToImport.map((e) => e.replace(/Enum$/, "")).join(", ")} } from './enums';
 
 `;
-    for (const typeName of typesToImport) {
+    for (const typeName of schemasToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
         let mockObject = {};
@@ -294,30 +313,30 @@ import type { ${typesToImport.join(", ")} } from './types';
   import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "index.ts"), indexContent.join("\n"));
   console.log(import_chalk.default.gray(`    \u2713 index.ts`));
 }
-function _propToZod(prop) {
+function _propToZod(prop, parentName) {
   let zodString = "z.any()";
-  const requiredMsg = { required_error: prop.description || generateFriendlyMessage(prop.name, "required") };
+  const errorMapParams = { errorMap: () => ({ message: prop.description || generateFriendlyMessage(prop.name, "required") }) };
   switch (prop.type) {
     case "string":
-      zodString = `z.string(${JSON.stringify(requiredMsg)})`;
+      zodString = `z.string(${JSON.stringify(errorMapParams)})`;
       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)})`;
+      if (prop.enum) zodString = `z.enum(${toPascalCase(parentName)}${toPascalCase(prop.name)}Enum)`;
       break;
     case "integer":
     case "number":
-      zodString = `z.number(${JSON.stringify(requiredMsg)})`;
+      zodString = `z.number(${JSON.stringify(errorMapParams)})`;
       break;
     case "boolean":
-      zodString = `z.boolean(${JSON.stringify(requiredMsg)})`;
+      zodString = `z.boolean(${JSON.stringify(errorMapParams)})`;
       break;
     case "array":
-      zodString = `z.array(${prop.items ? _propToZod(prop.items) : "z.any()"})`;
+      zodString = `z.array(${prop.items ? _propToZod(prop.items, `${parentName}${toPascalCase(prop.name)}Item`) : "z.any()"})`;
       break;
     case "object":
-      let shape = "z.any()";
+      let shape = "z.record(z.unknown())";
       if (prop.properties) shape = `z.object({
-${prop.properties.map((p) => `    ${p.name}: ${_propToZod(p)}`).join(",\n")}
+${prop.properties.map((p) => `    ${p.name}: ${_propToZod(p, `${parentName}${toPascalCase(prop.name)}`)}`).join(",\n")}
   })`;
       zodString = shape;
       break;
@@ -353,7 +372,7 @@ function _propToMock(prop) {
   }
 }
 async function runGenerator(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Phoenix Edition)..."));
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Diamond Edition)..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
   try {
@@ -361,13 +380,12 @@ async function runGenerator(options) {
 \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);
+    const { modules, allSchemas, allEnums } = 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);
+      await generateModuleFiles(module2, allSchemas, allEnums, options.output);
     }
     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."));

package/package.json

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