yedra 0.15.5 → 0.15.7

package/dist/lib.d.ts

@@ -2,7 +2,7 @@ export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, Fo
 export { Log } from './routing/log.js';
 export declare const validatePath: (path: string) => void;
 export { parseEnv } from './routing/env.js';
-export { array } from './validation/array.js';
+export { array } from './validation/modifiable.js';
 export { boolean } from './validation/boolean.js';
 export { date } from './validation/date.js';
 export { _enum as enum } from './validation/enum.js';

package/dist/lib.js

@@ -7,7 +7,7 @@ export const validatePath = (path) => {
 };
 export { parseEnv } from './routing/env.js';
 // validation
-export { array } from './validation/array.js';
+export { array } from './validation/modifiable.js';
 export { boolean } from './validation/boolean.js';
 export { date } from './validation/date.js';
 export { _enum as enum } from './validation/enum.js';

package/dist/validation/enum.d.ts

@@ -1,6 +1,7 @@
 import { ModifiableSchema } from './modifiable.js';
 declare class EnumSchema<T extends [...(string | number)[]]> extends ModifiableSchema<T[number]> {
     private readonly options;
+    private readonly normalized;
     constructor(options: T);
     parse(obj: unknown): T[number];
     documentation(): object;

package/dist/validation/enum.js

@@ -4,17 +4,26 @@ class EnumSchema extends ModifiableSchema {
     constructor(options) {
         super();
         this.options = options;
+        this.normalized = options.map((option) => option.toString());
     }
     parse(obj) {
-        if (!obj ||
-            (typeof obj !== 'string' && typeof obj !== 'number') ||
-            !this.options.includes(obj)) {
-            const actual = typeof obj === 'string' || typeof obj === 'number' ? obj : typeof obj;
+        if (typeof obj !== 'string' && typeof obj !== 'number') {
+            // enum objects can only be strings or numbers
             throw new ValidationError([
-                new Issue([], `Expected one of ${this.options.join(', ')} but got ${actual}`),
+                new Issue([], `Expected one of ${this.options.join(', ')} but got ${typeof obj}`),
             ]);
         }
-        return obj;
+        // compare only the stringified (normalized) values
+        const normalizedObj = obj.toString();
+        const index = this.normalized.findIndex((value) => value === normalizedObj);
+        if (index === -1) {
+            // invalid value
+            throw new ValidationError([
+                new Issue([], `Expected one of ${this.options.join(', ')} but got ${obj}`),
+            ]);
+        }
+        // return the un-normalized value
+        return this.options[index];
     }
     documentation() {
         return {

package/dist/validation/modifiable.d.ts

@@ -1,4 +1,4 @@
-import type { ArraySchema } from './array.js';
+import type { Typeof } from './body.js';
 import { DocSchema } from './doc.js';
 import { Schema } from './schema.js';
 export declare abstract class ModifiableSchema<T> extends Schema<T> {
@@ -27,4 +27,34 @@ declare class OptionalSchema<T> extends Schema<T | undefined> {
     documentation(): object;
     isOptional(): boolean;
 }
+export declare class ArraySchema<ItemSchema extends Schema<unknown>> extends ModifiableSchema<Typeof<ItemSchema>[]> {
+    private readonly itemSchema;
+    private readonly minItems?;
+    private readonly maxItems?;
+    constructor(itemSchema: ItemSchema, minItems?: number, maxItems?: number);
+    /**
+     * Set the minimum number of items for arrays.
+     * @param items - The minimum number of items.
+     */
+    min(items: number): ArraySchema<ItemSchema>;
+    /**
+     * Set the maximum number of items for arrays.
+     * @param items - The maximum number of items.
+     */
+    max(items: number): ArraySchema<ItemSchema>;
+    /**
+     * Set the exact number of items for arrays.
+     * This is equivalent to calling both min and max.
+     * @param items - The number of items.
+     */
+    length(items: number): ArraySchema<ItemSchema>;
+    parse(obj: unknown): Typeof<ItemSchema>[];
+    documentation(): object;
+}
+/**
+ * A schema matching arrays of the provided item type.
+ * @param itemSchema - The schema for array items.
+ * @deprecated Use the .array() method instead.
+ */
+export declare const array: <ItemSchema extends Schema<unknown>>(itemSchema: ItemSchema) => ArraySchema<ItemSchema>;
 export {};

package/dist/validation/modifiable.js

@@ -1,4 +1,5 @@
 import { DocSchema } from './doc.js';
+import { Issue, ValidationError } from './error.js';
 import { Schema } from './schema.js';
 export class ModifiableSchema extends Schema {
     /**
@@ -11,7 +12,7 @@ export class ModifiableSchema extends Schema {
         return new DocSchema(this, description, example);
     }
     array() {
-        return new ArraySchemaModule.ArraySchema(this);
+        return new ArraySchema(this);
     }
 }
 class OptionalSchema extends Schema {
@@ -31,7 +32,7 @@ class OptionalSchema extends Schema {
         return new DocSchema(this, description, example);
     }
     array() {
-        return new ArraySchemaModule.ArraySchema(this);
+        return new ArraySchema(this);
     }
     parse(obj) {
         if (obj === undefined || obj === null) {
@@ -46,4 +47,83 @@ class OptionalSchema extends Schema {
         return true;
     }
 }
-const ArraySchemaModule = await import('./array.js');
+export class ArraySchema extends ModifiableSchema {
+    constructor(itemSchema, minItems, maxItems) {
+        super();
+        this.itemSchema = itemSchema;
+        this.minItems = minItems;
+        this.maxItems = maxItems;
+    }
+    /**
+     * Set the minimum number of items for arrays.
+     * @param items - The minimum number of items.
+     */
+    min(items) {
+        return new ArraySchema(this.itemSchema, items, this.maxItems);
+    }
+    /**
+     * Set the maximum number of items for arrays.
+     * @param items - The maximum number of items.
+     */
+    max(items) {
+        return new ArraySchema(this.itemSchema, this.minItems, items);
+    }
+    /**
+     * Set the exact number of items for arrays.
+     * This is equivalent to calling both min and max.
+     * @param items - The number of items.
+     */
+    length(items) {
+        return new ArraySchema(this.itemSchema, items, items);
+    }
+    parse(obj) {
+        if (!Array.isArray(obj)) {
+            throw new ValidationError([
+                new Issue([], `Expected array but got ${typeof obj}`),
+            ]);
+        }
+        if (this.minItems && obj.length < this.minItems) {
+            throw new ValidationError([
+                new Issue([], `Must have at least ${this.minItems} items, but has ${obj.length}`),
+            ]);
+        }
+        if (this.maxItems && obj.length > this.maxItems) {
+            throw new ValidationError([
+                new Issue([], `Must have at most ${this.maxItems} items, but has ${obj.length}`),
+            ]);
+        }
+        const elems = [];
+        const issues = [];
+        for (let i = 0; i < obj.length; ++i) {
+            try {
+                elems.push(this.itemSchema.parse(obj[i]));
+            }
+            catch (error) {
+                if (error instanceof ValidationError) {
+                    issues.push(...error.withPrefix(i.toString()));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        if (issues.length > 0) {
+            throw new ValidationError(issues);
+        }
+        return elems;
+    }
+    documentation() {
+        return {
+            type: 'array',
+            items: this.itemSchema.documentation(),
+            minItems: this.minItems,
+            maxItems: this.maxItems,
+        };
+    }
+}
+/**
+ * A schema matching arrays of the provided item type.
+ * @param itemSchema - The schema for array items.
+ * @deprecated Use the .array() method instead.
+ */
+export const array = (itemSchema) => new ArraySchema(itemSchema);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "yedra",
-  "version": "0.15.5",
+  "version": "0.15.7",
   "repository": "github:0codekit/yedra",
   "main": "dist/index.js",
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@types/bun": "^1.2.16",
-    "@types/node": "^24.0.1",
+    "@types/node": "^24.0.3",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.18.1",
     "typescript": "^5.8.3"

package/dist/validation/array.d.ts

@@ -1,33 +0,0 @@
-import type { Typeof } from './body.js';
-import { ModifiableSchema } from './modifiable.js';
-import type { Schema } from './schema.js';
-export declare class ArraySchema<ItemSchema extends Schema<unknown>> extends ModifiableSchema<Typeof<ItemSchema>[]> {
-    private readonly itemSchema;
-    private readonly minItems?;
-    private readonly maxItems?;
-    constructor(itemSchema: ItemSchema, minItems?: number, maxItems?: number);
-    /**
-     * Set the minimum number of items for arrays.
-     * @param items - The minimum number of items.
-     */
-    min(items: number): ArraySchema<ItemSchema>;
-    /**
-     * Set the maximum number of items for arrays.
-     * @param items - The maximum number of items.
-     */
-    max(items: number): ArraySchema<ItemSchema>;
-    /**
-     * Set the exact number of items for arrays.
-     * This is equivalent to calling both min and max.
-     * @param items - The number of items.
-     */
-    length(items: number): ArraySchema<ItemSchema>;
-    parse(obj: unknown): Typeof<ItemSchema>[];
-    documentation(): object;
-}
-/**
- * A schema matching arrays of the provided item type.
- * @param itemSchema - The schema for array items.
- * @deprecated Use the .array() method instead.
- */
-export declare const array: <ItemSchema extends Schema<unknown>>(itemSchema: ItemSchema) => ArraySchema<ItemSchema>;

package/dist/validation/array.js

@@ -1,82 +0,0 @@
-import { Issue, ValidationError } from './error.js';
-import { ModifiableSchema } from './modifiable.js';
-export class ArraySchema extends ModifiableSchema {
-    constructor(itemSchema, minItems, maxItems) {
-        super();
-        this.itemSchema = itemSchema;
-        this.minItems = minItems;
-        this.maxItems = maxItems;
-    }
-    /**
-     * Set the minimum number of items for arrays.
-     * @param items - The minimum number of items.
-     */
-    min(items) {
-        return new ArraySchema(this.itemSchema, items, this.maxItems);
-    }
-    /**
-     * Set the maximum number of items for arrays.
-     * @param items - The maximum number of items.
-     */
-    max(items) {
-        return new ArraySchema(this.itemSchema, this.minItems, items);
-    }
-    /**
-     * Set the exact number of items for arrays.
-     * This is equivalent to calling both min and max.
-     * @param items - The number of items.
-     */
-    length(items) {
-        return new ArraySchema(this.itemSchema, items, items);
-    }
-    parse(obj) {
-        if (!Array.isArray(obj)) {
-            throw new ValidationError([
-                new Issue([], `Expected array but got ${typeof obj}`),
-            ]);
-        }
-        if (this.minItems && obj.length < this.minItems) {
-            throw new ValidationError([
-                new Issue([], `Must have at least ${this.minItems} items, but has ${obj.length}`),
-            ]);
-        }
-        if (this.maxItems && obj.length > this.maxItems) {
-            throw new ValidationError([
-                new Issue([], `Must have at most ${this.maxItems} items, but has ${obj.length}`),
-            ]);
-        }
-        const elems = [];
-        const issues = [];
-        for (let i = 0; i < obj.length; ++i) {
-            try {
-                elems.push(this.itemSchema.parse(obj[i]));
-            }
-            catch (error) {
-                if (error instanceof ValidationError) {
-                    issues.push(...error.withPrefix(i.toString()));
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        if (issues.length > 0) {
-            throw new ValidationError(issues);
-        }
-        return elems;
-    }
-    documentation() {
-        return {
-            type: 'array',
-            items: this.itemSchema.documentation(),
-            minItems: this.minItems,
-            maxItems: this.maxItems,
-        };
-    }
-}
-/**
- * A schema matching arrays of the provided item type.
- * @param itemSchema - The schema for array items.
- * @deprecated Use the .array() method instead.
- */
-export const array = (itemSchema) => new ArraySchema(itemSchema);