Merge pull request #1 from danimydev/v0.1.1

danimydev · web-flow · commit 311d79e13bef · 2025-11-15T18:05:57.000-05:00
V0.1.1
diff --git a/README.md b/README.md
@@ -1,35 +1,35 @@
 # @danimydev/env
 
-A TypeScript-first, runtime-safe environment variable reader. Works in Node.js, Deno, Bun, Browser, and Cloudflare Workers.
+A TypeScript-first, runtime-safe environment variable reader. Works in Node.js,
+Deno and Bun. If you want you can just copy the source code or install it via
+[jsr](https://jsr.io/@danimydev/env).
 
 ## Usage
+
 ```typescript
-import env, { string, number, boolean, object, optional } from "@danimydev/env";
-
-const config = env(
-  object({
-    NODE_ENV: string(),
-    PORT: number(),
-    DEBUG: optional(boolean())
-  })
-);
-
-console.log(config.NODE_ENV);
-console.log(config.PORT);
-console.log(config.DEBUG);
+import env, { boolean, number, optional, string } from "@danimydev/env";
+
+const config = env({
+  NODE_ENV: string(), // string,
+  PORT: number(), // number,
+  DEBUG: optional(boolean()), // boolean | undefined
+});
 ```
 
 ## Highlights
 
 - ✅ TypeScript-first: fully typed environment variable schemas.
-- 🌍 Cross-runtime: works in Node.js, Deno, Bun, Browser, Cloudflare Workers.
+- 🌍 Cross-runtime: works in Node.js, Deno and Bun.
 - 💡 Flexible: supports optional variables.
 - ⚡ Lightweight: zero dependencies, minimal overhead.
 
 ## License
 
-This project is released into the public domain under [The Unlicense](https://unlicense.org).  
+This project is released into the public domain under
+[The Unlicense](https://unlicense.org).
 
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software for any purpose.  
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software for any purpose.
 
-If you like the project, feel free to ⭐ [@danimydev/env on GitHub](https://github.com/danimydev/env)!
+If you like the project, feel free to ⭐
+[@danimydev/env on GitHub](https://github.com/danimydev/env)!
diff --git a/deno.json b/deno.json
@@ -1,6 +1,6 @@
 {
   "name": "@danimydev/env",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "exports": "./src/mod.ts",
   "tasks": {
diff --git a/src/boolean.ts b/src/boolean.ts
@@ -1,12 +1,12 @@
-import type { StandardSchema } from "./standard-schema.ts";
+import type { StandardSchemaV1 } from "./standard.ts";
 
 /**
  * A schema representing a boolean value.
  *
  * Validates boolean values, numeric 0/1, and string representations
  * such as `"true"`, `"false"`, `"1"`, `"0"`.
  */
-export interface BooleanSchema extends StandardSchema<boolean> {
+export interface BooleanSchema extends StandardSchemaV1<boolean> {
   /** The literal type of the schema */
   type: "boolean";
 
@@ -31,24 +31,31 @@ export interface BooleanSchema extends StandardSchema<boolean> {
 export function boolean(message: string = "Expected a boolean"): BooleanSchema {
   return {
     type: "boolean",
-    message,
+    message: message,
     "~standard": {
       validate(value) {
         if (typeof value === "boolean") return { value };
 
         if (typeof value === "string" || value instanceof String) {
           const primitive = value.toString();
+
           if (["TRUE", "True", "true", "1"].includes(primitive)) {
             return { value: true };
           }
+
           if (["FALSE", "False", "false", "0"].includes(primitive)) {
             return { value: false };
           }
         }
 
         if (typeof value === "number") {
-          if (value === 1) return { value: true };
-          if (value === 0) return { value: false };
+          if (value === 1) {
+            return { value: true };
+          }
+
+          if (value === 0) {
+            return { value: false };
+          }
         }
 
         return { issues: [{ message }] };
diff --git a/src/env.ts b/src/env.ts
@@ -1,33 +1,37 @@
-import type { StandardSchema } from "./standard-schema.ts";
-import { parse } from "./parse.ts";
+import type { StandardSchemaV1 } from "./standard.ts";
+import type { OptionalSchema } from "./optional.ts";
+import { object } from "./object.ts";
 import { getEnv, getRuntime } from "./runtime.ts";
+import { parse } from "./parse.ts";
 
 /**
- * Reads and validates environment variables based on the provided schema.
+ * Reads and validates environment variables based on the provided record of schemas.
  *
  * Main entry point of the `@danimydev/env` library.
  *
  * ```ts
- * import env, { string, number, boolean, object, optional } from "@danimydev/env";
+ * import env, { string, number, boolean, optional } from "@danimydev/env";
  *
- * const config = env(
- *   object({
+ * const safeEnv = env({
  *     NODE_ENV: string(),
  *     PORT: number(),
  *     DEBUG: optional(boolean()),
- *   })
- * );
+ * });
  * ```
  *
  * @typeParam TSchema - The schema type.
- * @param schema - A `StandardSchema` describing the expected environment shape.
+ * @param schema - A `StandardSchemaV1` describing the expected environment shape.
  * @returns The validated and typed environment object.
  * @throws {Error} If any variable fails validation.
  */
-export function env<TSchema extends StandardSchema>(
-  schema: TSchema,
-): StandardSchema.InferOutput<TSchema> {
-  const runtime = getRuntime();
-  const env = getEnv(runtime);
-  return parse(schema, env);
+export function env<
+  TShape extends Record<
+    string,
+    | StandardSchemaV1<string | number | boolean>
+    | OptionalSchema<StandardSchemaV1<string | number | boolean>>
+  >,
+>(
+  shape: TShape,
+): { [K in keyof TShape]: StandardSchemaV1.InferOutput<TShape[K]> } {
+  return parse(object(shape), getEnv(getRuntime()));
 }
diff --git a/src/mod.ts b/src/mod.ts
@@ -1,9 +1,7 @@
-import { object } from "./object.ts";
 import { string } from "./string.ts";
 import { number } from "./number.ts";
 import { boolean } from "./boolean.ts";
 import { optional } from "./optional.ts";
-import { parse } from "./parse.ts";
 import { env } from "./env.ts";
 
 /**
@@ -14,6 +12,6 @@ import { env } from "./env.ts";
  * - `parse`: Parse and validate arbitrary input against a schema.
  * - `string`, `number`, `boolean`, `object`, `optional`: Standard schema constructors.
  */
-export { boolean, env, number, object, optional, parse, string };
+export { boolean, env, number, optional, string };
 
 export default env;
diff --git a/src/number.ts b/src/number.ts
@@ -1,11 +1,11 @@
-import type { StandardSchema } from "./standard-schema.ts";
+import type { StandardSchemaV1 } from "./standard.ts";
 
 /**
  * A schema representing a numeric value.
  *
  * Validates that the input is a number or a string representing a number.
  */
-export interface NumberSchema extends StandardSchema<number> {
+export interface NumberSchema extends StandardSchemaV1<number> {
   /** The literal type of the schema */
   type: "number";
 
diff --git a/src/object.ts b/src/object.ts
@@ -1,4 +1,4 @@
-import type { StandardSchema } from "./standard-schema.ts";
+import type { StandardSchemaV1 } from "./standard.ts";
 import type { OptionalSchema } from "./optional.ts";
 
 /**
@@ -9,13 +9,13 @@ import type { OptionalSchema } from "./optional.ts";
 export interface ObjectSchema<
   TShape extends Record<
     string,
-    | StandardSchema<string | number | boolean>
-    | OptionalSchema<StandardSchema<string | number | boolean>>
+    | StandardSchemaV1<string | number | boolean>
+    | OptionalSchema<StandardSchemaV1<string | number | boolean>>
   >,
 > extends
-  StandardSchema<
+  StandardSchemaV1<
     Record<string, unknown>,
-    { [K in keyof TShape]: StandardSchema.InferOutput<TShape[K]> }
+    { [K in keyof TShape]: StandardSchemaV1.InferOutput<TShape[K]> }
   > {
   /** The literal type of the schema */
   type: "object";
@@ -45,8 +45,8 @@ export interface ObjectSchema<
 export function object<
   TShape extends Record<
     string,
-    | StandardSchema<string | number | boolean>
-    | OptionalSchema<StandardSchema<string | number | boolean>>
+    | StandardSchemaV1<string | number | boolean>
+    | OptionalSchema<StandardSchemaV1<string | number | boolean>>
   >,
 >(shape: TShape, message = "Expected an object"): ObjectSchema<TShape> {
   return {
@@ -62,7 +62,7 @@ export function object<
         }
 
         const result: Record<string, unknown> = {};
-        const issues: StandardSchema.Issue[] = [];
+        const issues: StandardSchemaV1.Issue[] = [];
 
         for (const key in shape) {
           const fieldSchema = shape[key];
@@ -85,15 +85,15 @@ export function object<
 
         return issues.length > 0
           ? { issues }
-          : { value: result } as StandardSchema.SuccessResult<
-            { [K in keyof TShape]: StandardSchema.InferOutput<TShape[K]> }
+          : { value: result } as StandardSchemaV1.SuccessResult<
+            { [K in keyof TShape]: StandardSchemaV1.InferOutput<TShape[K]> }
           >;
       },
 
       types: {
         input: {} as Record<string, unknown>,
         output: {} as {
-          [K in keyof TShape]: StandardSchema.InferOutput<TShape[K]>;
+          [K in keyof TShape]: StandardSchemaV1.InferOutput<TShape[K]>;
         },
       },
     },
diff --git a/src/optional.ts b/src/optional.ts
@@ -1,13 +1,13 @@
-import type { StandardSchema } from "./standard-schema.ts";
+import type { StandardSchemaV1 } from "./standard.ts";
 
 /**
  * A schema representing an optional value.
  *
  * Wraps another schema and allows `undefined` or `null` values.
  */
 export interface OptionalSchema<
-  TSchema extends StandardSchema<string | number | boolean>,
-> extends StandardSchema<StandardSchema.InferOutput<TSchema> | undefined> {
+  TSchema extends StandardSchemaV1<string | number | boolean>,
+> extends StandardSchemaV1<StandardSchemaV1.InferOutput<TSchema> | undefined> {
   /** The literal type of the schema */
   type: "optional";
 
@@ -32,7 +32,7 @@ export interface OptionalSchema<
  * @returns An `OptionalSchema` instance.
  */
 export function optional<
-  TSchema extends StandardSchema<string | number | boolean>,
+  TSchema extends StandardSchemaV1<string | number | boolean>,
 >(schema?: TSchema, message = "Value is optional"): OptionalSchema<TSchema> {
   return {
     type: "optional",
@@ -43,6 +43,7 @@ export function optional<
         if (value === undefined || value === null || schema === undefined) {
           return { value: undefined };
         }
+
         return schema["~standard"].validate(value);
       },
     },
diff --git a/src/parse.ts b/src/parse.ts
@@ -1,4 +1,4 @@
-import type { StandardSchema } from "./standard-schema.ts";
+import type { StandardSchemaV1 } from "./standard.ts";
 
 /**
  * Validates and parses an input according to a schema.
@@ -12,15 +12,15 @@ import type { StandardSchema } from "./standard-schema.ts";
  * ```
  *
  * @typeParam TSchema - The schema type.
- * @param schema - The `StandardSchema` to validate against.
+ * @param schema - The `StandardSchemaV1` to validate against.
  * @param input - The value to validate.
  * @returns The validated value.
  * @throws {Error} If validation fails.
  */
-export function parse<TSchema extends StandardSchema>(
+export function parse<TSchema extends StandardSchemaV1>(
   schema: TSchema,
   input: unknown,
-): StandardSchema.InferOutput<TSchema> {
+): StandardSchemaV1.InferOutput<TSchema> {
   const result = schema["~standard"].validate(input);
 
   if (result.issues) {
diff --git a/src/runtime.ts b/src/runtime.ts
diff --git a/src/runtime_test.ts b/src/runtime_test.ts
diff --git a/src/standard.ts b/src/standard.ts
diff --git a/src/string.ts b/src/string.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@danimydev/env",`
`3`		`- "version": "0.1.0",`
	`3`	`+ "version": "0.1.1",`
`4`	`4`	`"license": "MIT",`
`5`	`5`	`"exports": "./src/mod.ts",`
`6`	`6`	`"tasks": {`