yedra 0.15.6 → 0.16.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as y from './lib.js';
 export { y };
 export { Yedra } from './routing/app.js';
-export { Get, Post, Put, Delete } from './routing/rest.js';
+export { BadRequestError, ConflictError, ForbiddenError, HttpError, NotFoundError, PaymentRequiredError, UnauthorizedError, } from './routing/errors.js';
+export { Delete, Get, Post, Put } from './routing/rest.js';
 export { Ws } from './routing/websocket.js';
-export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, ForbiddenError, NotFoundError, ConflictError, } from './routing/errors.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 import * as y from './lib.js';
 export { y };
 export { Yedra } from './routing/app.js';
-export { Get, Post, Put, Delete } from './routing/rest.js';
+export { BadRequestError, ConflictError, ForbiddenError, HttpError, NotFoundError, PaymentRequiredError, UnauthorizedError, } from './routing/errors.js';
+export { Delete, Get, Post, Put } from './routing/rest.js';
 export { Ws } from './routing/websocket.js';
-export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, ForbiddenError, NotFoundError, ConflictError, } from './routing/errors.js';

package/dist/lib.d.ts

@@ -1,22 +1,23 @@
-export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, ForbiddenError, NotFoundError, ConflictError, } from './routing/errors.js';
+export { BadRequestError, ConflictError, ForbiddenError, HttpError, NotFoundError, PaymentRequiredError, UnauthorizedError, } from './routing/errors.js';
 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 { SecurityScheme } from './util/security.js';
+export { BodyType, type Typeof } from './validation/body.js';
 export { boolean } from './validation/boolean.js';
 export { date } from './validation/date.js';
+export { either } from './validation/either.js';
 export { _enum as enum } from './validation/enum.js';
-export { _null as null } from './validation/null.js';
 export { ValidationError } from './validation/error.js';
-export { number } from './validation/number.js';
 export { integer } from './validation/integer.js';
-export { object, laxObject } from './validation/object.js';
+export { array } from './validation/modifiable.js';
+export { _null as null } from './validation/null.js';
+export { number } from './validation/number.js';
+export { laxObject, object } from './validation/object.js';
+export { raw } from './validation/raw.js';
 export { record } from './validation/record.js';
 export { Schema } from './validation/schema.js';
-export { BodyType, type Typeof } from './validation/body.js';
-export { raw } from './validation/raw.js';
 export { stream } from './validation/stream.js';
-export { either } from './validation/either.js';
 export { string } from './validation/string.js';
 export { union } from './validation/union.js';
 export { unknown } from './validation/unknown.js';

package/dist/lib.js

@@ -1,27 +1,28 @@
 import { Path } from './routing/path.js';
 // routing
-export { HttpError, BadRequestError, UnauthorizedError, PaymentRequiredError, ForbiddenError, NotFoundError, ConflictError, } from './routing/errors.js';
+export { BadRequestError, ConflictError, ForbiddenError, HttpError, NotFoundError, PaymentRequiredError, UnauthorizedError, } from './routing/errors.js';
 export { Log } from './routing/log.js';
 export const validatePath = (path) => {
     new Path(path);
 };
 export { parseEnv } from './routing/env.js';
-// validation
-export { array } from './validation/array.js';
+export { SecurityScheme } from './util/security.js';
+export { BodyType } from './validation/body.js';
 export { boolean } from './validation/boolean.js';
 export { date } from './validation/date.js';
+export { either } from './validation/either.js';
 export { _enum as enum } from './validation/enum.js';
-export { _null as null } from './validation/null.js';
 export { ValidationError } from './validation/error.js';
-export { number } from './validation/number.js';
 export { integer } from './validation/integer.js';
-export { object, laxObject } from './validation/object.js';
+// validation
+export { array } from './validation/modifiable.js';
+export { _null as null } from './validation/null.js';
+export { number } from './validation/number.js';
+export { laxObject, object } from './validation/object.js';
+export { raw } from './validation/raw.js';
 export { record } from './validation/record.js';
 export { Schema } from './validation/schema.js';
-export { BodyType } from './validation/body.js';
-export { raw } from './validation/raw.js';
 export { stream } from './validation/stream.js';
-export { either } from './validation/either.js';
 export { string } from './validation/string.js';
 export { union } from './validation/union.js';
 export { unknown } from './validation/unknown.js';

package/dist/routing/app.d.ts

@@ -1,7 +1,6 @@
 import type { IncomingMessage, Server, ServerResponse } from 'node:http';
 import { WebSocketServer } from 'ws';
 import { Counter } from '../util/counter.js';
-import type { SecurityScheme } from '../util/security.js';
 import { RestEndpoint } from './rest.js';
 import { WsEndpoint } from './websocket.js';
 declare class Context {
@@ -23,27 +22,35 @@ type ServeConfig = {
     dir: string;
     fallback?: string | ServeFallback;
 };
+type DocsData = {
+    /**
+     * The title of your API.
+     */
+    title: string;
+    /**
+     * The description of your API.
+     */
+    description: string;
+    /**
+     * The current version of your API.
+     */
+    version: string;
+    /**
+     * The list of servers your API is reachable under.
+     */
+    servers?: {
+        description: string;
+        url: string;
+    }[];
+};
 type ConnectMiddleware = (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
 export declare class Yedra {
     private restRoutes;
     private wsRoutes;
     private requestData;
+    private generatedDocs;
     use(path: string, endpoint: RestEndpoint | WsEndpoint | Yedra): Yedra;
-    /**
-     * Generate OpenAPI documentation for the app.
-     */
-    docs(options: {
-        info: {
-            title: string;
-            description: string;
-            version: string;
-        };
-        security?: Record<string, SecurityScheme>;
-        servers: {
-            description: string;
-            url: string;
-        }[];
-    }): object;
+    private generateDocs;
     private static loadServe;
     private performRequest;
     private middlewareNext;
@@ -57,6 +64,11 @@ export declare class Yedra {
             path: string;
             get?: () => Promise<string> | string;
         };
+        /**
+         * Configuration for the `/openapi.json` endpoint, which generates
+         * OpenAPI documentation.
+         */
+        docs?: DocsData;
         serve?: ServeConfig;
         /**
          * Prevents all normal output from Yedra. Mostly useful for tests.

package/dist/routing/app.js

@@ -1,4 +1,4 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
+import { readdir, readFile, stat } from 'node:fs/promises';
 import { createServer as createHttpServer } from 'node:http';
 import { createServer as createHttpsServer } from 'node:https';
 import { extname, join } from 'node:path';
@@ -43,7 +43,10 @@ export class Yedra {
         if (endpoint instanceof Yedra) {
             for (const route of endpoint.restRoutes) {
                 const newPath = route.path.withPrefix(path);
-                this.restRoutes.push({ path: newPath, endpoint: route.endpoint });
+                this.restRoutes.push({
+                    path: newPath,
+                    endpoint: route.endpoint,
+                });
             }
             for (const route of endpoint.wsRoutes) {
                 const newPath = route.path.withPrefix(path);
@@ -61,10 +64,9 @@ export class Yedra {
         }
         return this;
     }
-    /**
-     * Generate OpenAPI documentation for the app.
-     */
-    docs(options) {
+    generateDocs(options) {
+        // this set will be filled with the security schemes from all endpoints
+        const securitySchemes = new Set();
         const paths = {};
         for (const route of this.restRoutes) {
             if (route.endpoint.isHidden()) {
@@ -74,18 +76,25 @@ export class Yedra {
             const path = route.path.toString();
             const methods = paths[path] ?? {};
             methods[route.endpoint.method.toLowerCase()] =
-                route.endpoint.documentation(path, options.security ?? {});
+                route.endpoint.documentation(path, securitySchemes);
             paths[path] = methods;
         }
-        return {
+        this.generatedDocs = JSON.stringify({
             openapi: '3.0.2',
-            info: options.info,
+            info: {
+                title: options?.title ?? 'Yedra API',
+                description: options?.description ??
+                    'This is an OpenAPI documentation generated automatically by Yedra.',
+                version: options?.version ?? '0.1.0',
+            },
             components: {
-                securitySchemes: options.security,
+                securitySchemes: Object.fromEntries(securitySchemes
+                    .values()
+                    .map((scheme) => [scheme.name, scheme.scheme])),
             },
-            servers: options.servers,
+            servers: options?.servers ?? [],
             paths,
-        };
+        });
     }
     static async loadServe(config) {
         if (config === undefined) {
@@ -137,6 +146,19 @@ export class Yedra {
             req.method !== 'DELETE') {
             return Yedra.errorResponse(405, `Method \`${req.method}\` not allowed.`);
         }
+        if (req.method === 'GET' && req.url.pathname === '/openapi.json') {
+            if (this.generatedDocs === undefined) {
+                console.error('Docs were not generated correctly.');
+                return Yedra.errorResponse(500, 'Internal Server Error');
+            }
+            return {
+                status: 200,
+                body: Buffer.from(this.generatedDocs ?? '{}', 'utf-8'),
+                headers: {
+                    'content-type': 'application/json',
+                },
+            };
+        }
         const match = this.matchRestRoute(req.url.pathname, req.method);
         if (!match.result) {
             // no matching route found
@@ -155,7 +177,9 @@ export class Yedra {
                 }
                 if (serveData.fallback !== undefined) {
                     try {
-                        const response = await serveData.fallback({ href: req.url.href });
+                        const response = await serveData.fallback({
+                            href: req.url.href,
+                        });
                         return {
                             status: response.status ?? 200,
                             body: isUint8Array(response.body)
@@ -211,6 +235,7 @@ export class Yedra {
     }
     async listen(port, options) {
         const serveData = await Yedra.loadServe(options?.serve);
+        this.generateDocs(options?.docs);
         const server = options?.tls === undefined
             ? createHttpServer()
             : createHttpsServer({
@@ -320,7 +345,7 @@ export class Yedra {
     }
     matchRestRoute(url, method) {
         let invalidMethod = false;
-        let result = undefined;
+        let result;
         for (const route of this.restRoutes) {
             const match = route.path.match(url);
             if (match === undefined) {
@@ -340,7 +365,7 @@ export class Yedra {
         return { invalidMethod, result };
     }
     matchWsRoute(url) {
-        let result = undefined;
+        let result;
         for (const route of this.wsRoutes) {
             const match = route.path.match(url);
             if (match === undefined) {

package/dist/routing/path.js

@@ -19,7 +19,7 @@ export class Path {
             .substring(1)
             .split('/')
             .filter((segment) => segment !== '');
-        const invalidSegment = this.expected.find((part) => part.match(/^((:?[A-Za-z0-9\-\.]+\??)|\*)$/) === null);
+        const invalidSegment = this.expected.find((part) => part.match(/^((:?[A-Za-z0-9\-.]+\??)|\*)$/) === null);
         if (invalidSegment) {
             throw new Error(`API path ${path} is invalid: Segment ${invalidSegment} does not match regex /^((:?[A-Za-z0-9-\.]+\\??)|\\*)$/.`);
         }

package/dist/routing/rest.d.ts

@@ -25,10 +25,9 @@ type EndpointOptions<Params extends Record<string, Schema<unknown>>, Query exten
     summary: string;
     description?: string;
     /**
-     * List of security definitions that apply to this endpoint.
-     * Security definitions need to be included in the `app.docs()` call.
+     * List of security schemes that apply to this endpoint.
      */
-    security?: string[];
+    security?: SecurityScheme[];
     /**
      * Whether this endpoint should be excluded from the documentation.
      * Default is false.
@@ -55,8 +54,13 @@ export declare abstract class RestEndpoint {
         headers?: Record<string, string>;
     }>;
     abstract isHidden(): boolean;
-    abstract documentation(path: string, securitySchemes: Record<string, SecurityScheme>): object;
+    abstract documentation(path: string, securitySchemes: Set<SecurityScheme>): object;
 }
+/**
+ * This class implements all REST endpoints in yedra. Its parent class,
+ * `RestEndpoint`, is not abstract because there are multiple implementations,
+ * but so that we can hide all the generic parameters of this class.
+ */
 declare class ConcreteRestEndpoint<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Req extends BodyType<unknown>, Res extends BodyType<unknown>> extends RestEndpoint {
     private _method;
     private options;
@@ -77,7 +81,7 @@ declare class ConcreteRestEndpoint<Params extends Record<string, Schema<unknown>
         headers?: Record<string, string>;
     }>;
     isHidden(): boolean;
-    documentation(path: string, securitySchemes: Record<string, SecurityScheme>): object;
+    documentation(path: string, securitySchemes: Set<SecurityScheme>): object;
 }
 export declare class Get<Params extends Record<string, Schema<unknown>>, Query extends Record<string, Schema<unknown>>, Headers extends Record<string, Schema<unknown>>, Res extends BodyType<unknown>> extends ConcreteRestEndpoint<Params, Query, Headers, NoneBody, Res> {
     constructor(options: Omit<EndpointOptions<Params, Query, Headers, NoneBody, Res>, 'req'>);

package/dist/routing/rest.js

@@ -5,6 +5,11 @@ import { laxObject, object } from '../validation/object.js';
 import { BadRequestError } from './errors.js';
 export class RestEndpoint {
 }
+/**
+ * This class implements all REST endpoints in yedra. Its parent class,
+ * `RestEndpoint`, is not abstract because there are multiple implementations,
+ * but so that we can hide all the generic parameters of this class.
+ */
 class ConcreteRestEndpoint extends RestEndpoint {
     constructor(method, options) {
         super();
@@ -92,19 +97,22 @@ class ConcreteRestEndpoint extends RestEndpoint {
         return this.options.hidden ?? false;
     }
     documentation(path, securitySchemes) {
+        const security = this.options.security ?? [];
+        for (const scheme of security) {
+            // add all our security schemes to the global list of schemes
+            securitySchemes.add(scheme);
+        }
         const parameters = [
-            ...paramDocs(this.options.params, 'path', this.options.security ?? [], securitySchemes),
-            ...paramDocs(this.options.query, 'query', this.options.security ?? [], securitySchemes),
-            ...paramDocs(this.options.headers, 'header', this.options.security ?? [], securitySchemes),
+            ...paramDocs(this.options.params, 'path', security),
+            ...paramDocs(this.options.query, 'query', security),
+            ...paramDocs(this.options.headers, 'header', security),
         ];
         return {
             tags: [this.options.category],
             summary: this.options.summary,
             description: this.options.description,
             operationId: `${path.substring(1).replaceAll('/', '_')}_${this.method.toLowerCase()}`,
-            security: this.options.security !== undefined
-                ? this.options.security.map((security) => ({ [security]: [] }))
-                : [],
+            security: security.map((security) => ({ [security.name]: [] })),
             parameters,
             requestBody: this.options.req instanceof NoneBody
                 ? undefined

package/dist/routing/websocket.js

@@ -89,8 +89,8 @@ export class Ws extends WsEndpoint {
     }
     documentation() {
         const parameters = [
-            ...paramDocs(this.options.params, 'path', [], {}),
-            ...paramDocs(this.options.query, 'query', [], {}),
+            ...paramDocs(this.options.params, 'path', []),
+            ...paramDocs(this.options.query, 'query', []),
         ];
         return {
             tags: [this.options.category],

package/dist/util/docs.d.ts

@@ -6,4 +6,4 @@ import type { SecurityScheme } from './security.js';
  * @param position - The position of the parameter, e.g. `path`, `query`, `header`. This is passed directly to OpenAPI.
  * @returns A list of parameter documentations in OpenAPI format.
  */
-export declare const paramDocs: <Params extends Record<string, Schema<unknown>>>(params: Params, position: "path" | "query" | "header", security: string[], securitySchemes: Record<string, SecurityScheme>) => object[];
+export declare const paramDocs: <Params extends Record<string, Schema<unknown>>>(params: Params, position: "path" | "query" | "header", security: SecurityScheme[]) => object[];

package/dist/util/docs.js

@@ -4,10 +4,10 @@
  * @param position - The position of the parameter, e.g. `path`, `query`, `header`. This is passed directly to OpenAPI.
  * @returns A list of parameter documentations in OpenAPI format.
  */
-export const paramDocs = (params, position, security, securitySchemes) => {
+export const paramDocs = (params, position, security) => {
     const result = [];
     for (const name in params) {
-        if (isAuthToken(name, position, security, securitySchemes)) {
+        if (isAuthToken(name, position, security)) {
             // don't include auth tokens in the documentation, they're already
             // handled by the separate authentication feature of OpenAPI
             continue;
@@ -32,16 +32,13 @@ export const paramDocs = (params, position, security, securitySchemes) => {
  * @param securitySchemes - The security scheme definitions.
  * @returns Whether the parameter is an auth token.
  */
-const isAuthToken = (paramName, position, security, securitySchemes) => {
+const isAuthToken = (paramName, position, securitySchemes) => {
     if (position === 'path') {
-        // parameters cannot be auth tokens
+        // path parameters cannot be auth tokens
         return false;
     }
-    for (const [securityName, securityScheme] of Object.entries(securitySchemes)) {
-        if (!security.includes(securityName)) {
-            continue;
-        }
-        if (securityScheme.type === 'http') {
+    for (const scheme of securitySchemes) {
+        if (scheme.scheme.type === 'http') {
             if (paramName.toLowerCase() === 'authorization' &&
                 position === 'header') {
                 // http auth token has to be in authorization header
@@ -49,8 +46,9 @@ const isAuthToken = (paramName, position, security, securitySchemes) => {
             }
         }
         else {
-            if (securityScheme.in === position && securityScheme.name === paramName) {
-                // api key has to have the correct name and be in the correct position
+            if (scheme.scheme.in === position &&
+                paramName.toLowerCase() === scheme.scheme.name.toLowerCase()) {
+                // API key has to have the correct name and be in the correct position
                 return true;
             }
         }

package/dist/util/security.d.ts

@@ -1,4 +1,9 @@
-export type SecurityScheme = {
+export declare class SecurityScheme {
+    name: string;
+    scheme: SecuritySchemeData;
+    constructor(name: string, scheme: SecuritySchemeData);
+}
+type SecuritySchemeData = {
     type: 'http';
     scheme: 'basic' | 'bearer';
 } | {
@@ -6,3 +11,4 @@ export type SecurityScheme = {
     in: 'header' | 'query' | 'cookie';
     name: string;
 };
+export {};

package/dist/util/security.js

@@ -1 +1,6 @@
-export {};
+export class SecurityScheme {
+    constructor(name, scheme) {
+        this.name = name;
+        this.scheme = scheme;
+    }
+}

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,30 +1,41 @@
 {
-  "name": "yedra",
-  "version": "0.15.6",
-  "repository": "github:0codekit/yedra",
-  "main": "dist/index.js",
-  "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
-    "@types/bun": "^1.2.16",
-    "@types/node": "^24.0.3",
-    "@types/uuid": "^10.0.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.8.3"
-  },
-  "bugs": "https://github.com/0codekit/yedra/issues",
-  "contributors": ["Justus Zorn <jzorn@wemakefuture.com>"],
-  "description": "A TypeScript web framework with OpenAPI generation.",
-  "keywords": ["typescript", "web", "http", "schema", "validation", "openapi"],
-  "license": "MIT",
-  "files": ["./dist/**"],
-  "scripts": {
-    "check": "biome check src/*"
-  },
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "dependencies": {
-    "mime": "^4.0.7",
-    "uuid": "^11.1.0",
-    "ws": "^8.18.2"
-  }
+	"name": "yedra",
+	"version": "0.16.0",
+	"repository": "github:0codekit/yedra",
+	"main": "dist/index.js",
+	"devDependencies": {
+		"@biomejs/biome": "^2.0.6",
+		"@types/bun": "^1.2.17",
+		"@types/node": "^24.0.7",
+		"@types/uuid": "^10.0.0",
+		"@types/ws": "^8.18.1",
+		"typescript": "^5.8.3"
+	},
+	"bugs": "https://github.com/0codekit/yedra/issues",
+	"contributors": [
+		"Justus Zorn <jzorn@wemakefuture.com>"
+	],
+	"description": "A TypeScript web framework with OpenAPI generation.",
+	"keywords": [
+		"typescript",
+		"web",
+		"http",
+		"schema",
+		"validation",
+		"openapi"
+	],
+	"license": "MIT",
+	"files": [
+		"./dist/**"
+	],
+	"scripts": {
+		"check": "biome check src/*"
+	},
+	"types": "dist/index.d.ts",
+	"type": "module",
+	"dependencies": {
+		"mime": "^4.0.7",
+		"uuid": "^11.1.0",
+		"ws": "^8.18.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);