api-core-lib 12.0.73 → 12.0.74

package/dist/cli.cjs

@@ -74,6 +74,132 @@ 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) {
+  const getMessages = (keys, customErrorMessages) => {
+    const messages = {};
+    const keyMap = {
+      required: "required_error",
+      invalid_type: "invalid_type_error"
+    };
+    for (const key of keys) {
+      const zodKey = keyMap[key] || "message";
+      const customMessage = customErrorMessages?.[key];
+      messages[zodKey] = customMessage || `validation.${key}`;
+    }
+    return messages;
+  };
+  let zodChain;
+  switch (prop.type) {
+    case "string": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.string(${JSON.stringify(messages)})`;
+      if (prop.enum && prop.enum.length > 0) {
+        zodChain = `z.enum(${JSON.stringify(prop.enum)}, ${JSON.stringify(messages)})`;
+      } else {
+        if (prop.minLength !== void 0) {
+          const msg = { message: prop.errorMessages?.minLength || "validation.string.min" };
+          zodChain += `.min(${prop.minLength}, ${JSON.stringify(msg)})`;
+        } else if (prop.isRequired) {
+          const msg = { message: prop.errorMessages?.minLength || "validation.string.nonempty" };
+          zodChain += `.min(1, ${JSON.stringify(msg)})`;
+        }
+        if (prop.maxLength !== void 0) {
+          const msg = { message: prop.errorMessages?.maxLength || "validation.string.max" };
+          zodChain += `.max(${prop.maxLength}, ${JSON.stringify(msg)})`;
+        }
+        if (prop.pattern) {
+          const msg = { message: prop.errorMessages?.pattern || "validation.string.regex" };
+          zodChain += `.regex(/${prop.pattern}/, ${JSON.stringify(msg)})`;
+        }
+        if (prop.format) {
+          const msg = { message: prop.errorMessages?.format || `validation.string.${prop.format}` };
+          if (prop.format === "email") zodChain += `.email(${JSON.stringify(msg)})`;
+          if (prop.format === "url") zodChain += `.url(${JSON.stringify(msg)})`;
+          if (prop.format === "uuid") zodChain += `.uuid(${JSON.stringify(msg)})`;
+          if (prop.format === "datetime") zodChain += `.datetime(${JSON.stringify(msg)})`;
+        }
+      }
+      break;
+    }
+    case "integer": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      const intMessage = { message: prop.errorMessages?.integer || "validation.number.integer" };
+      zodChain = `z.number(${JSON.stringify(messages)}).int(${JSON.stringify(intMessage)})`;
+      if (prop.minimum !== void 0) {
+        const msg = { message: prop.errorMessages?.minimum || "validation.number.min" };
+        zodChain += `.min(${prop.minimum}, ${JSON.stringify(msg)})`;
+      }
+      if (prop.maximum !== void 0) {
+        const msg = { message: prop.errorMessages?.maximum || "validation.number.max" };
+        zodChain += `.max(${prop.maximum}, ${JSON.stringify(msg)})`;
+      }
+      break;
+    }
+    case "number": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.number(${JSON.stringify(messages)})`;
+      if (prop.minimum !== void 0) {
+        const msg = { message: prop.errorMessages?.minimum || "validation.number.min" };
+        zodChain += `.min(${prop.minimum}, ${JSON.stringify(msg)})`;
+      }
+      if (prop.maximum !== void 0) {
+        const msg = { message: prop.errorMessages?.maximum || "validation.number.max" };
+        zodChain += `.max(${prop.maximum}, ${JSON.stringify(msg)})`;
+      }
+      break;
+    }
+    case "boolean": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.boolean(${JSON.stringify(messages)})`;
+      break;
+    }
+    case "array": {
+      const itemSchema = prop.items ? _propToZod(prop.items) : "z.any()";
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.array(${itemSchema}, ${JSON.stringify(messages)})`;
+      if (prop.minItems !== void 0) {
+        const msg = { message: prop.errorMessages?.minItems || "validation.array.min" };
+        zodChain += `.min(${prop.minItems}, ${JSON.stringify(msg)})`;
+      }
+      if (prop.maxItems !== void 0) {
+        const msg = { message: prop.errorMessages?.maxItems || "validation.array.max" };
+        zodChain += `.max(${prop.maxItems}, ${JSON.stringify(msg)})`;
+      }
+      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()";
+  }
+  if (prop.defaultValue !== void 0) {
+    zodChain += `.default(${JSON.stringify(prop.defaultValue)})`;
+  }
+  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 }));
@@ -321,71 +447,6 @@ 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) {
-  let chain;
-  const requiredErrorMessage = { required_error: `${prop.name} is required.` };
-  switch (prop.type) {
-    case "string":
-      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":
-      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":
-      chain = `z.boolean({ ...requiredErrorMessage, invalid_type_error: "Expected a boolean for ${prop.name}" })`;
-      break;
-    case "array":
-      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":
-      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()";
-  }
-  return chain;
-}
 function _propToMock(prop) {
   if (prop.example) return prop.example;
   if (prop.name.match(/image|avatar|logo|url/i)) return "https://via.placeholder.com/150";

package/package.json

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