api-core-lib 12.0.70 → 12.0.73

package/dist/cli.cjs

@@ -82,8 +82,8 @@ 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).replace(/V\d+$/, "");
+var sanitizeForModuleName = (tagName) => `${toPascalCase(tagName.replace(/[^a-zA-Z0-9]/g, " "))}Api`;
+var getActionName = (opId) => toCamelCase(opId.replace(/^(central|tenant)/i, "").replace(/_v\d+$/, ""));
 var findCommonPath = (paths) => {
   if (!paths || paths.length === 0) return "/";
   const sorted = [...paths].sort();
@@ -94,7 +94,6 @@ var findCommonPath = (paths) => {
   const prefix = first.substring(0, i);
   return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
 };
-var generateFriendlyMessage = (fieldName) => `${fieldName.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase())} is required.`;
 function parseSchema(name, schema, allEnums) {
   const properties = [];
   const enums = {};
@@ -137,9 +136,7 @@ function parseSpecToModules(spec) {
     if (schema.type === "array" && schema.items) {
       const itemSchema = schema.items;
       const itemBaseName = `${baseName}Item`;
-      if (itemSchema.properties || itemSchema.type === "object") {
-        return `${registerSchema(itemSchema, itemBaseName)}[]`;
-      }
+      if (itemSchema.properties || itemSchema.type === "object") return `${registerSchema(itemSchema, itemBaseName)}[]`;
       return `${itemSchema.type || "unknown"}[]`;
     }
     if (schema.type === "object" || schema.properties || schema.allOf || !schema.type) {
@@ -155,8 +152,9 @@ function parseSpecToModules(spec) {
     for (const method in pathItem) {
       if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
       const endpoint = pathItem[method];
-      if (!endpoint.operationId) continue;
-      const moduleName = getModuleName(endpoint.operationId);
+      if (!endpoint.tags || endpoint.tags.length === 0 || !endpoint.operationId) continue;
+      const tagName = endpoint.tags[0];
+      const moduleName = sanitizeForModuleName(tagName);
       if (!modules.has(moduleName)) {
         modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set(), enums: /* @__PURE__ */ new Set() });
         modulePaths.set(moduleName, []);
@@ -178,7 +176,8 @@ function parseSpecToModules(spec) {
           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) => {
@@ -265,9 +264,7 @@ ${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 ? `{
-${prop.properties.map((p) => `    ${p.name}${p.isRequired ? "" : "?"}: ${p.type};
-`).join("")}  }` : `Record<string, 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};
 `;
         }
@@ -288,7 +285,7 @@ import { z } from 'zod';
     for (const typeName of schemasToImport) {
       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}
 });
@@ -324,37 +321,70 @@ 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 errorParams = { required_error: prop.description || generateFriendlyMessage(prop.name) };
+function _propToZod(prop) {
+  let chain;
+  const requiredErrorMessage = { required_error: `${prop.name} is required.` };
   switch (prop.type) {
     case "string":
-      zodString = `z.string(${JSON.stringify(errorParams)})`;
-      if (prop.format === "email") zodString += `.email({ message: "Invalid email address" })`;
-      if (prop.format === "uuid") zodString += `.uuid()`;
-      if (prop.enum) zodString = `z.enum(${toPascalCase(parentName)}${toPascalCase(prop.name)}Enum, ${JSON.stringify(errorParams)})`;
+      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(errorParams)})`;
+      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(errorParams)})`;
+      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.description) {
+    chain += `.describe(${JSON.stringify(prop.description)})`;
+  }
+  if (!prop.isRequired) {
+    chain += ".optional()";
+  }
+  if (prop.isNullable) {
+    chain += ".nullable()";
   }
-  if (!prop.isRequired) zodString = zodString.replace(/\(.*\)/, "").trim() + ".optional()";
-  if (prop.isNullable) zodString += ".nullable()";
-  return zodString;
+  return chain;
 }
 function _propToMock(prop) {
   if (prop.example) return prop.example;
@@ -383,7 +413,7 @@ function _propToMock(prop) {
   }
 }
 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 (Sapphire Edition)..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
   try {

package/package.json

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