api-core-lib 12.0.69 → 12.0.72

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, colors: true }));
+[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);
@@ -94,20 +94,14 @@ var findCommonPath = (paths) => {
   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());
-  return `${friendlyName} is required.`;
-};
-function parseSchema(name, schema, allEnums) {
+function parseSchema(name, schema) {
   const properties = [];
-  const enums = {};
   if (schema.properties) {
     for (const propName in schema.properties) {
       const propSchema = schema.properties[propName];
-      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 });
+      let items = void 0;
+      if (propSchema.type === "array" && propSchema.items) {
+        items = parseSchema("item", propSchema.items).properties[0];
       }
       properties.push({
         name: propName,
@@ -118,24 +112,24 @@ function parseSchema(name, schema, allEnums) {
         example: propSchema.example,
         enum: propSchema.enum,
         format: propSchema.format,
-        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
+        items,
+        // نستخدم المتغير الذي تم حسابه بأمان
+        properties: propSchema.properties ? parseSchema("sub-object", propSchema).properties : void 0
       });
     }
   }
-  return { name, description: schema.description, properties, enums };
+  return { name, description: schema.description, properties };
 }
 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, allEnums));
+      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema));
       return typeName;
     }
     return schema.type === "integer" ? "number" : schema.type || "unknown";
@@ -149,7 +143,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(), enums: /* @__PURE__ */ new Set() });
+        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set() });
         modulePaths.set(moduleName, []);
       }
       const currentModule = modules.get(moduleName);
@@ -165,33 +159,35 @@ 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`));
         }
       });
-      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 };
+      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 };
     }
   }
   modules.forEach((mod, name) => {
-    mod.baseEndpoint = findCommonPath(modulePaths.get(name));
-    Object.values(mod.actions).forEach((action) => action.path = action.path.replace(mod.baseEndpoint, "").replace(/^\//, "") || "/");
+    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;
+    });
   });
   debugLog("Final Parsed Modules", Object.fromEntries(modules));
-  return { modules, allSchemas, allEnums };
+  return { modules, allSchemas };
 }
-async function generateModuleFiles(module2, allSchemas, allEnums, outputDir) {
+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 schemasToImport = [...module2.schemas].sort();
-  const enumsToImport = [...module2.enums].sort();
+  const typesToImport = [...module2.schemas].sort();
   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';
+  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) => {
@@ -213,32 +209,11 @@ ${actionsValue}
   const indexContent = [`// This file is auto-generated.
 
 export * from './config';`];
-  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';`);
-    }
+  if (typesToImport.length > 0) {
     let typesContent = `// This file is auto-generated.
 
 `;
-    if (enumsToImport.length > 0) typesContent += `import type { ${enumsToImport.join(", ")} } from './enums';
-
-`;
-    for (const typeName of schemasToImport) {
+    for (const typeName of typesToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
         if (parsedSchema.description) typesContent += `/**
@@ -253,10 +228,7 @@ export * from './config';`];
 ${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.properties ? `${toPascalCase(`${typeName}${toPascalCase(prop.name)}Item`)}[]` : `${prop.items.type}[]`;
-          else if (prop.properties) propType = `Record<string, unknown>`;
+          const propType = prop.enum ? prop.enum.map((e) => typeof e === "string" ? `'${e}'` : e).join(" | ") : prop.items ? `${toPascalCase(prop.items.name)}[]` : prop.type;
           typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
 `;
         }
@@ -270,14 +242,12 @@ ${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 schemasToImport) {
+    for (const typeName of typesToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
-        let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p, typeName)}`).join(",\n");
+        let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
         validationContent += `export const ${typeName}Schema = z.object({
 ${zodShape}
 });
@@ -289,12 +259,10 @@ ${zodShape}
     console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
     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.map((e) => e.replace(/Enum$/, "")).join(", ")} } from './enums';
+import type { ${typesToImport.join(", ")} } from './types';
 
 `;
-    for (const typeName of schemasToImport) {
+    for (const typeName of typesToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
         let mockObject = {};
@@ -313,66 +281,144 @@ import type { ${schemasToImport.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, parentName) {
-  let zodString = "z.any()";
-  const errorMapParams = { errorMap: () => ({ message: prop.description || generateFriendlyMessage(prop.name, "required") }) };
+function _propToZod(prop) {
+  let chain;
+  const requiredErrorMessage = { required_error: `${prop.name} is required.` };
   switch (prop.type) {
     case "string":
-      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(${toPascalCase(parentName)}${toPascalCase(prop.name)}Enum)`;
+      chain = `z.string({ ...requiredErrorMessage, invalid_type_error: "Expected a string for ${prop.name}" })`;
+      if (prop.format === "email") chain += `.email({ message: "Invalid email address for ${prop.name}" })`;
+      if (prop.format === "uuid") chain += `.uuid({ message: "Invalid UUID for ${prop.name}" })`;
+      if (prop.format === "url") chain += `.url({ message: "Invalid URL for ${prop.name}" })`;
+      if (prop.format === "datetime") chain += `.datetime({ message: "Invalid datetime format for ${prop.name}" })`;
+      if (prop.minLength !== void 0) chain += `.min(${prop.minLength}, { message: "${prop.name} must be at least ${prop.minLength} characters long" })`;
+      if (prop.maxLength !== void 0) chain += `.max(${prop.maxLength}, { message: "${prop.name} must be at most ${prop.maxLength} characters long" })`;
+      if (prop.pattern) chain += `.regex(/${prop.pattern}/, { message: "Invalid format for ${prop.name}" })`;
+      if (prop.enum) {
+        if (prop.enum.length > 0) {
+          chain = `z.enum(${JSON.stringify(prop.enum)})`;
+        } else {
+          chain = `z.string().refine(() => false, { message: "Enum for ${prop.name} is empty" })`;
+        }
+      }
       break;
     case "integer":
+      chain = `z.number({ ...requiredErrorMessage, invalid_type_error: "Expected a number for ${prop.name}" }).int({ message: "${prop.name} must be an integer" })`;
+      if (prop.minimum !== void 0) chain += `.min(${prop.minimum}, { message: "${prop.name} must be at least ${prop.minimum}" })`;
+      if (prop.maximum !== void 0) chain += `.max(${prop.maximum}, { message: "${prop.name} must be at most ${prop.maximum}" })`;
+      break;
     case "number":
-      zodString = `z.number(${JSON.stringify(errorMapParams)})`;
+      chain = `z.number({ ...requiredErrorMessage, invalid_type_error: "Expected a number for ${prop.name}" })`;
+      if (prop.minimum !== void 0) chain += `.min(${prop.minimum}, { message: "${prop.name} must be at least ${prop.minimum}" })`;
+      if (prop.maximum !== void 0) chain += `.max(${prop.maximum}, { message: "${prop.name} must be at most ${prop.maximum}" })`;
       break;
     case "boolean":
-      zodString = `z.boolean(${JSON.stringify(errorMapParams)})`;
+      chain = `z.boolean({ ...requiredErrorMessage, invalid_type_error: "Expected a boolean for ${prop.name}" })`;
       break;
     case "array":
-      zodString = `z.array(${prop.items ? _propToZod(prop.items, `${parentName}${toPascalCase(prop.name)}Item`) : "z.any()"})`;
+      const itemSchema = prop.items ? _propToZod(prop.items) : "z.any()";
+      chain = `z.array(${itemSchema})`;
+      if (prop.minItems !== void 0) chain += `.min(${prop.minItems}, { message: "${prop.name} must contain at least ${prop.minItems} item(s)" })`;
+      if (prop.maxItems !== void 0) chain += `.max(${prop.maxItems}, { message: "${prop.name} must contain at most ${prop.maxItems} item(s)" })`;
       break;
     case "object":
-      let shape = "z.record(z.unknown())";
-      if (prop.properties) shape = `z.object({
-${prop.properties.map((p) => `    ${p.name}: ${_propToZod(p, `${parentName}${toPascalCase(prop.name)}`)}`).join(",\n")}
-  })`;
-      zodString = shape;
+      if (prop.properties && prop.properties.length > 0) {
+        const shape = prop.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
+        chain = `z.object({
+${shape}
+})`;
+      } else {
+        chain = "z.record(z.unknown())";
+      }
+      break;
+    default:
+      chain = "z.any()";
       break;
   }
-  if (!prop.isRequired) zodString += ".optional()";
-  if (prop.isNullable) zodString += ".nullable()";
-  return zodString;
+  if (prop.description) {
+    chain += `.describe(${JSON.stringify(prop.description)})`;
+  }
+  if (!prop.isRequired) {
+    chain += ".optional()";
+  }
+  if (prop.isNullable) {
+    chain += ".nullable()";
+  }
+  return chain;
+}
+function _generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
 }
+function _getRandomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+var _firstNames = ["Ahmed", "Fatima", "Mohammed", "Zainab", "Ali", "Nour"];
+var _lastNames = ["Al-Masri", "Khan", "Hassan", "Abbas", "Said"];
 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];
+  if (prop.example !== void 0) {
+    return prop.example;
+  }
+  if (prop.enum && prop.enum.length > 0) {
+    return prop.enum[_getRandomInt(0, prop.enum.length - 1)];
+  }
   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)}`;
+      if (prop.format === "email") return `user${_getRandomInt(1, 1e3)}@example.com`;
+      if (prop.format === "uuid") return _generateUUID();
+      if (prop.format === "url") return "https://www.example.com";
+      if (prop.format === "datetime") return (/* @__PURE__ */ new Date()).toISOString();
+      const name = prop.name.toLowerCase();
+      if (name.includes("image") || name.includes("avatar") || name.includes("logo") || name.includes("picture")) return `https://via.placeholder.com/${_getRandomInt(150, 400)}`;
+      if (name.includes("firstname")) return _firstNames[_getRandomInt(0, _firstNames.length - 1)];
+      if (name.includes("lastname")) return _lastNames[_getRandomInt(0, _lastNames.length - 1)];
+      if (name.includes("name")) return `${_firstNames[_getRandomInt(0, _firstNames.length - 1)]} ${_lastNames[_getRandomInt(0, _lastNames.length - 1)]}`;
+      if (name.includes("city")) return "Riyadh";
+      if (name.includes("country")) return "Saudi Arabia";
+      if (name.includes("phone")) return `+1-${_getRandomInt(100, 999)}-${_getRandomInt(100, 999)}-${_getRandomInt(1e3, 9999)}`;
+      if (name.includes("description") || name.includes("comment")) return "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+      const minLen = prop.minLength || 8;
+      const maxLen = prop.maxLength || 16;
+      return `Mock${toPascalCase(prop.name)}`.padEnd(_getRandomInt(minLen, maxLen), "x");
     case "integer":
     case "number":
-      return 1;
+      const min = prop.minimum === void 0 ? 1 : prop.minimum;
+      const max = prop.maximum === void 0 ? 1e3 : prop.maximum;
+      const randomNum = _getRandomInt(min, max);
+      return prop.type === "integer" ? Math.floor(randomNum) : randomNum + Math.random();
     case "boolean":
-      return true;
+      return Math.random() > 0.5;
     case "array":
-      return prop.items ? [_propToMock(prop.items)] : [];
+      const minItems = prop.minItems || 1;
+      const maxItems = prop.maxItems || 3;
+      const count = _getRandomInt(minItems, maxItems);
+      if (!prop.items) return [];
+      const items = [];
+      for (let i = 0; i < count; i++) {
+        items.push(_propToMock(prop.items));
+      }
+      return items;
     case "object":
       const mock = {};
-      if (prop.properties) prop.properties.forEach((p) => {
-        mock[p.name] = _propToMock(p);
-      });
+      if (prop.properties) {
+        prop.properties.forEach((p) => {
+          if (p.isRequired || Math.random() > 0.3) {
+            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 (Diamond Edition)..."));
+  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";
   try {
@@ -380,12 +426,13 @@ 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, allEnums } = parseSpecToModules(spec);
+    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, allEnums, options.output);
+      await generateModuleFiles(module2, allSchemas, 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.69",
+  "version": "12.0.72",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {