zenvx 0.1.0 → 0.1.3

package/README.md

@@ -26,6 +26,14 @@ Standard Zod is great, but environment variables are always strings. This leads
 
 ---
 
+## Features
+
+- ✅ Type-safe environment variables
+- ✅ Smart coercion for numbers, booleans, and ports
+- ✅ Strict validation for strings, URLs, emails, JSON, enums
+- ✅ Beautiful, human-readable error reporting
+- ✅ Seamless TypeScript integration
+
 ## Installation
 
 ```bash
@@ -42,7 +50,7 @@ yarn add zenvx zod
 
 Create a file (e.g., src/env.ts) and export your configuration:
 
-```javascript
+```ts
 import { defineEnv, tx } from "zenvx";
 
 export const env = defineEnv({
@@ -61,7 +69,7 @@ export const env = defineEnv({
 
 Now use it anywhere in your app:
 
-```javascript
+```ts
 import { env } from "./env";
 
 console.log(`Server running on port ${env.PORT}`);
@@ -95,13 +103,12 @@ DATABASE_URL: Must be a valid URL
 | `tx.email()`     | Valid email address.                                               | `"admin@app.com"`    | `"admin@..."`   |
 | `tx.json()`      | Parses a JSON string into an Object.                               | `{"foo":"bar"}`      | `{foo: "bar"}`  |
 | `tx.enum([...])` | Strict allow-list.                                                 | `"PROD"`             | `"PROD"`        |
-| `tx.ip()`        | Validates IPv4 format.                                             | `"192.168.1.1"`      | `"192..."`      |
 
 ## Customizing Error Messages
 
 Every tx validator accepts an optional custom error message.
 
-```javascript
+```ts
 export const env = defineEnv({
   API_KEY: tx.string("Please provide a REAL API Key, not just numbers!"),
   PORT: tx.port("Port is invalid or out of range"),
@@ -114,7 +121,7 @@ Custom .env Path
 
 By default, zenvx looks for .env in your project root. You can change this:
 
-```javascript
+```ts
 export const env = defineEnv(
   {
     PORT: tx.port(),
@@ -129,7 +136,7 @@ export const env = defineEnv(
 
 You can mix tx helpers with standard Zod schemas if you need specific logic.
 
-```javascript
+```ts
 import { defineEnv, tx } from "zenvx";
 import { z } from "zod";
 

package/dist/index.cjs

@@ -95,71 +95,95 @@ var tx = {
    * Rejects purely numeric strings (e.g. "12345").
    * Good for API Keys.
    */
-  string: (message) => import_zod2.z.string().refine((val) => !/^\d+$/.test(val), {
-    error: message || "Value should be text, but looks like a number."
-  }),
+  string: (message) => {
+    return import_zod2.z.string().refine((val) => !/^\d+$/.test(val), {
+      error: message || "Value should be text, but looks like a number."
+    });
+  },
   /**
    * SMART NUMBER:
    * Automatically converts "3000" -> 3000.
    * Fails if the value is not a valid number (e.g. "abc").
    */
-  number: (message) => import_zod2.z.coerce.number({ error: message || "Must be a number" }),
+  number: (message) => {
+    return import_zod2.z.coerce.number({ error: message || "Must be a number" });
+  },
   /**
    * PORT VALIDATOR:
    * Coerces to number and ensures it is between 1 and 65535.
    */
-  port: (message) => import_zod2.z.coerce.number().min(1).max(65535).catch((ctx) => {
-    ctx.error;
-    return -1;
-  }).refine((val) => val >= 1 && val <= 65535, {
-    error: message || "Must be a valid port (1-65535)."
-  }),
+  port: (message) => {
+    return import_zod2.z.coerce.number({
+      error: message || "Must be a valid port (1-65535)"
+    }).min(1, { error: message || "Port must be >= 1" }).max(65535, { error: message || "Port must be <= 65535" });
+  },
   /**
    * SMART BOOLEAN:
    * Handles "true", "TRUE", "1" -> true
    * Handles "false", "FALSE", "0" -> false
    * Throws error on anything else.
    */
-  bool: (message) => import_zod2.z.string().transform((val, ctx) => {
-    const v = val.toLowerCase();
-    if (v === "true" || v === "1") return true;
-    if (v === "false" || v === "0") return false;
-    ctx.addIssue({
-      code: import_zod2.z.ZodIssueCode.custom,
-      error: message || "Must be a boolean (true/false or 1/0)."
+  bool: (message) => {
+    return import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean()]).transform((val, ctx) => {
+      if (typeof val === "boolean") return val;
+      const v = val.toLowerCase();
+      if (v === "true" || v === "1") return true;
+      if (v === "false" || v === "0") return false;
+      ctx.addIssue({
+        code: import_zod2.z.ZodIssueCode.custom,
+        message: message || 'Must be a boolean ("true"/"false"/"1"/"0")'
+      });
+      return import_zod2.z.NEVER;
     });
-    return import_zod2.z.NEVER;
-  }),
+  },
   /**
    * URL:
    * Strict URL checking.
    */
-  url: (message) => import_zod2.z.url({ error: message || "Must be a valid URL (e.g. https://...)" }),
+  url: (message) => {
+    return import_zod2.z.url({
+      error: message || "Must be a valid URL (e.g. https://...)"
+    });
+  },
   /**
    * EMAIL:
    * Strict Email checking.
    */
-  email: (message) => import_zod2.z.email({ error: message || "Must be a valid email address." }),
-  positiveNumber: (message) => import_zod2.z.coerce.number().refine((val) => val > 0, { error: message || "Must be > 0" }),
-  nonEmptyString: (message) => import_zod2.z.string().min(1, { error: message || "Cannot be empty" }),
-  semver: (message) => import_zod2.z.string().refine((val) => /^\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?$/.test(val), {
-    error: message || "Must be valid semver"
-  }),
-  path: (message) => import_zod2.z.string().min(1, { error: message || "Must be a valid path" }),
-  enum: (values, message) => import_zod2.z.string().refine((val) => values.includes(val), {
-    error: message || `Must be one of: ${values.join(", ")}`
-  }),
-  json: (message) => import_zod2.z.string().transform((val, ctx) => {
-    try {
-      return JSON.parse(val);
-    } catch {
-      ctx.addIssue({
-        code: import_zod2.z.ZodIssueCode.custom,
-        message: message || "Must be valid JSON"
-      });
-      return import_zod2.z.NEVER;
-    }
-  })
+  email: (message) => {
+    return import_zod2.z.email({ error: message || "Must be a valid email address." });
+  },
+  positiveNumber: (message) => {
+    return import_zod2.z.coerce.number().gt(0, { message: message || "Must be > 0" });
+  },
+  nonEmptyString: (message) => {
+    return import_zod2.z.string().trim().min(1, { message: message || "Cannot be empty" });
+  },
+  semver: (message) => {
+    return import_zod2.z.string().refine((val) => /^\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?$/.test(val), {
+      error: message || "Must be valid semver"
+    });
+  },
+  path: (message) => {
+    return import_zod2.z.string().min(1, { error: message || "Must be a valid path" });
+  },
+  enum: (values, message) => {
+    return import_zod2.z.string().refine((val) => values.includes(val), {
+      error: message || `Must be one of: ${values.join(", ")}`
+    });
+  },
+  json: (message) => {
+    return import_zod2.z.string().transform((val, ctx) => {
+      try {
+        return JSON.parse(val);
+      } catch {
+        ctx.addIssue({
+          code: import_zod2.z.ZodIssueCode.custom,
+          message: message || "Must be valid JSON"
+        });
+        return import_zod2.z.NEVER;
+      }
+    });
+  }
 };
 function defineEnv(shape, options) {
   const fileEnv = loadDotEnv(options?.path);

package/dist/index.d.cts

@@ -20,14 +20,14 @@ declare const tx: {
      * PORT VALIDATOR:
      * Coerces to number and ensures it is between 1 and 65535.
      */
-    port: (message?: string) => z.ZodCatch<z.ZodCoercedNumber<unknown>>;
+    port: (message?: string) => z.ZodCoercedNumber<unknown>;
     /**
      * SMART BOOLEAN:
      * Handles "true", "TRUE", "1" -> true
      * Handles "false", "FALSE", "0" -> false
      * Throws error on anything else.
      */
-    bool: (message?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>;
+    bool: (message?: string) => z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>, z.ZodTransform<boolean, string | boolean>>;
     /**
      * URL:
      * Strict URL checking.

package/dist/index.d.ts

@@ -20,14 +20,14 @@ declare const tx: {
      * PORT VALIDATOR:
      * Coerces to number and ensures it is between 1 and 65535.
      */
-    port: (message?: string) => z.ZodCatch<z.ZodCoercedNumber<unknown>>;
+    port: (message?: string) => z.ZodCoercedNumber<unknown>;
     /**
      * SMART BOOLEAN:
      * Handles "true", "TRUE", "1" -> true
      * Handles "false", "FALSE", "0" -> false
      * Throws error on anything else.
      */
-    bool: (message?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>;
+    bool: (message?: string) => z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>, z.ZodTransform<boolean, string | boolean>>;
     /**
      * URL:
      * Strict URL checking.

package/dist/index.js

@@ -60,71 +60,95 @@ var tx = {
    * Rejects purely numeric strings (e.g. "12345").
    * Good for API Keys.
    */
-  string: (message) => z2.string().refine((val) => !/^\d+$/.test(val), {
-    error: message || "Value should be text, but looks like a number."
-  }),
+  string: (message) => {
+    return z2.string().refine((val) => !/^\d+$/.test(val), {
+      error: message || "Value should be text, but looks like a number."
+    });
+  },
   /**
    * SMART NUMBER:
    * Automatically converts "3000" -> 3000.
    * Fails if the value is not a valid number (e.g. "abc").
    */
-  number: (message) => z2.coerce.number({ error: message || "Must be a number" }),
+  number: (message) => {
+    return z2.coerce.number({ error: message || "Must be a number" });
+  },
   /**
    * PORT VALIDATOR:
    * Coerces to number and ensures it is between 1 and 65535.
    */
-  port: (message) => z2.coerce.number().min(1).max(65535).catch((ctx) => {
-    ctx.error;
-    return -1;
-  }).refine((val) => val >= 1 && val <= 65535, {
-    error: message || "Must be a valid port (1-65535)."
-  }),
+  port: (message) => {
+    return z2.coerce.number({
+      error: message || "Must be a valid port (1-65535)"
+    }).min(1, { error: message || "Port must be >= 1" }).max(65535, { error: message || "Port must be <= 65535" });
+  },
   /**
    * SMART BOOLEAN:
    * Handles "true", "TRUE", "1" -> true
    * Handles "false", "FALSE", "0" -> false
    * Throws error on anything else.
    */
-  bool: (message) => z2.string().transform((val, ctx) => {
-    const v = val.toLowerCase();
-    if (v === "true" || v === "1") return true;
-    if (v === "false" || v === "0") return false;
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      error: message || "Must be a boolean (true/false or 1/0)."
+  bool: (message) => {
+    return z2.union([z2.string(), z2.boolean()]).transform((val, ctx) => {
+      if (typeof val === "boolean") return val;
+      const v = val.toLowerCase();
+      if (v === "true" || v === "1") return true;
+      if (v === "false" || v === "0") return false;
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: message || 'Must be a boolean ("true"/"false"/"1"/"0")'
+      });
+      return z2.NEVER;
     });
-    return z2.NEVER;
-  }),
+  },
   /**
    * URL:
    * Strict URL checking.
    */
-  url: (message) => z2.url({ error: message || "Must be a valid URL (e.g. https://...)" }),
+  url: (message) => {
+    return z2.url({
+      error: message || "Must be a valid URL (e.g. https://...)"
+    });
+  },
   /**
    * EMAIL:
    * Strict Email checking.
    */
-  email: (message) => z2.email({ error: message || "Must be a valid email address." }),
-  positiveNumber: (message) => z2.coerce.number().refine((val) => val > 0, { error: message || "Must be > 0" }),
-  nonEmptyString: (message) => z2.string().min(1, { error: message || "Cannot be empty" }),
-  semver: (message) => z2.string().refine((val) => /^\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?$/.test(val), {
-    error: message || "Must be valid semver"
-  }),
-  path: (message) => z2.string().min(1, { error: message || "Must be a valid path" }),
-  enum: (values, message) => z2.string().refine((val) => values.includes(val), {
-    error: message || `Must be one of: ${values.join(", ")}`
-  }),
-  json: (message) => z2.string().transform((val, ctx) => {
-    try {
-      return JSON.parse(val);
-    } catch {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        message: message || "Must be valid JSON"
-      });
-      return z2.NEVER;
-    }
-  })
+  email: (message) => {
+    return z2.email({ error: message || "Must be a valid email address." });
+  },
+  positiveNumber: (message) => {
+    return z2.coerce.number().gt(0, { message: message || "Must be > 0" });
+  },
+  nonEmptyString: (message) => {
+    return z2.string().trim().min(1, { message: message || "Cannot be empty" });
+  },
+  semver: (message) => {
+    return z2.string().refine((val) => /^\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?$/.test(val), {
+      error: message || "Must be valid semver"
+    });
+  },
+  path: (message) => {
+    return z2.string().min(1, { error: message || "Must be a valid path" });
+  },
+  enum: (values, message) => {
+    return z2.string().refine((val) => values.includes(val), {
+      error: message || `Must be one of: ${values.join(", ")}`
+    });
+  },
+  json: (message) => {
+    return z2.string().transform((val, ctx) => {
+      try {
+        return JSON.parse(val);
+      } catch {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: message || "Must be valid JSON"
+        });
+        return z2.NEVER;
+      }
+    });
+  }
 };
 function defineEnv(shape, options) {
   const fileEnv = loadDotEnv(options?.path);

package/package.json

@@ -1,10 +1,26 @@
 {
   "name": "zenvx",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "keywords": [
+    "env",
+    "environment-variables",
+    "configuration",
+    "config",
+    "dotenv",
+    "zod",
+    "typescript",
+    "validation",
+    "schema",
+    "type-safe",
+    "strict-env",
+    "parser",
+    "process.env"
+  ],
+  "license": "MIT",
   "author": {
     "name": "Sean Wilfred T. Custodio",
     "email": "custodiocsean@gmail.com"