yedra 0.20.11 → 0.20.13

package/dist/src/validation/object.js

@@ -0,0 +1,87 @@
+import { Issue, ValidationError } from './error.js';
+import { ModifiableSchema } from './modifiable.js';
+import { Schema } from './schema.js';
+export class ObjectSchema extends ModifiableSchema {
+    constructor(shape, lax) {
+        super();
+        this.shape = shape;
+        this.lax = lax;
+    }
+    parse(obj) {
+        if (typeof obj !== 'object') {
+            throw new ValidationError([
+                new Issue([], `Expected object but got ${typeof obj}`),
+            ]);
+        }
+        if (obj == null) {
+            throw new ValidationError([
+                new Issue([], 'Expected object but got null'),
+            ]);
+        }
+        const result = {};
+        const issues = [];
+        for (const prop in this.shape) {
+            const propSchema = this.shape[prop];
+            if (propSchema instanceof Schema) {
+                if (!(prop in obj || propSchema.isOptional())) {
+                    issues.push(new Issue([prop], 'Required'));
+                    continue;
+                }
+                try {
+                    result[prop] = propSchema.parse(obj[prop]);
+                }
+                catch (error) {
+                    if (error instanceof ValidationError) {
+                        issues.push(...error.withPrefix(prop));
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        }
+        if (!this.lax) {
+            for (const prop in obj) {
+                if (prop in this.shape) {
+                    continue;
+                }
+                issues.push(new Issue([prop], 'Unrecognized'));
+            }
+        }
+        if (issues.length > 0) {
+            throw new ValidationError(issues);
+        }
+        return result;
+    }
+    documentation() {
+        const properties = {};
+        const required = [];
+        for (const prop in this.shape) {
+            const propSchema = this.shape[prop];
+            if (propSchema instanceof Schema) {
+                if (!propSchema.isOptional()) {
+                    required.push(prop);
+                }
+                properties[prop] = propSchema.documentation();
+            }
+        }
+        return {
+            type: 'object',
+            properties,
+            additionalProperties: this.lax,
+            ...(required.length > 0 && { required }),
+        };
+    }
+}
+/**
+ * A schema matching a JavaScript object of the specified shape. Fields which
+ * can be undefined are automatically marked as optional.
+ * @param shape - The object shape.
+ *
+ * ```typescript
+ * const schema = y.object({ num: y.number(), str: y.string().optional() });
+ * type SchemaType = y.Typeof<typeof schema>; // { num: number, str?: string }
+ * ```
+ */
+export const object = (shape) => new ObjectSchema(shape, false);
+export const laxObject = (shape) => new ObjectSchema(shape, true);

package/dist/src/validation/raw.d.ts

@@ -0,0 +1,13 @@
+import type { Readable } from 'node:stream';
+import { BodyType } from './body.js';
+declare class RawBody extends BodyType<Buffer<ArrayBuffer>, Buffer<ArrayBufferLike>> {
+    private contentType;
+    constructor(contentType: string);
+    deserialize(stream: Readable, _contentType: string): Promise<Buffer<ArrayBuffer>>;
+    bodyDocs(): object;
+}
+/**
+ * Accepts a raw buffer of the specified content type.
+ */
+export declare const raw: (contentType?: string) => RawBody;
+export {};

package/dist/src/validation/raw.js

@@ -0,0 +1,21 @@
+import { readableToBuffer } from '../util/stream.js';
+import { BodyType } from './body.js';
+class RawBody extends BodyType {
+    constructor(contentType) {
+        super();
+        this.contentType = contentType;
+    }
+    async deserialize(stream, _contentType) {
+        const buffer = await readableToBuffer(stream);
+        return buffer;
+    }
+    bodyDocs() {
+        return {
+            [this.contentType]: {},
+        };
+    }
+}
+/**
+ * Accepts a raw buffer of the specified content type.
+ */
+export const raw = (contentType) => new RawBody(contentType ?? 'application/octet-stream');

package/dist/src/validation/record.d.ts

@@ -0,0 +1,16 @@
+import type { Typeof } from './body.js';
+import { ModifiableSchema } from './modifiable.js';
+import type { Schema } from './schema.js';
+declare class RecordSchema<ValueSchema extends Schema<unknown>> extends ModifiableSchema<Record<string, Typeof<ValueSchema> | undefined>> {
+    private readonly valueSchema;
+    constructor(valueSchema: ValueSchema);
+    parse(obj: unknown): Record<string, Typeof<ValueSchema> | undefined>;
+    documentation(): object;
+}
+/**
+ * A schema matching a JavaScript object with arbitrary keys. Every value has
+ * to match the specified value schema.
+ * @param valueSchema - The schema for the record values.
+ */
+export declare const record: <ValueSchema extends Schema<unknown>>(valueSchema: ValueSchema) => RecordSchema<ValueSchema>;
+export {};

package/dist/src/validation/record.js

@@ -0,0 +1,51 @@
+import { Issue, ValidationError } from './error.js';
+import { ModifiableSchema } from './modifiable.js';
+class RecordSchema extends ModifiableSchema {
+    constructor(valueSchema) {
+        super();
+        this.valueSchema = valueSchema;
+    }
+    parse(obj) {
+        if (typeof obj !== 'object') {
+            throw new ValidationError([
+                new Issue([], `Expected object but got ${typeof obj}`),
+            ]);
+        }
+        if (obj === null) {
+            throw new ValidationError([
+                new Issue([], 'Expected object but got null'),
+            ]);
+        }
+        const result = {};
+        const issues = [];
+        for (const key in obj) {
+            try {
+                result[key] = this.valueSchema.parse(obj[key]);
+            }
+            catch (error) {
+                if (error instanceof ValidationError) {
+                    issues.push(...error.withPrefix(key));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        if (issues.length > 0) {
+            throw new ValidationError(issues);
+        }
+        return result;
+    }
+    documentation() {
+        return {
+            type: 'object',
+            additionalProperties: this.valueSchema.documentation(),
+        };
+    }
+}
+/**
+ * A schema matching a JavaScript object with arbitrary keys. Every value has
+ * to match the specified value schema.
+ * @param valueSchema - The schema for the record values.
+ */
+export const record = (valueSchema) => new RecordSchema(valueSchema);

package/dist/src/validation/schema.d.ts

@@ -0,0 +1,35 @@
+import type { Readable } from 'node:stream';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { BodyType } from './body.js';
+/**
+ * The base class for all schemas.
+ */
+export declare abstract class Schema<T> extends BodyType<T, T> implements StandardSchemaV1<T, T> {
+    deserialize(stream: Readable, contentType: string): Promise<T>;
+    bodyDocs(): object;
+    /**
+     * Parse the object with this schema. This throws a
+     * `ValidationError` if the object is invalid.
+     * @param obj - The object to be parsed.
+     */
+    abstract parse(obj: unknown): T;
+    /**
+     * Generate a JSON schema for this schema.
+     */
+    abstract documentation(): object;
+    /**
+     * Whether the schema is allowed to be optional.
+     */
+    isOptional(): boolean;
+    /**
+     * Standard Schema V1 compliance. This allows yedra schemas to be used
+     * directly with libraries that accept Standard Schema validators
+     * (e.g. TanStack Form, TanStack Router, tRPC).
+     *
+     * This is a non-breaking addition — it does not affect `parse()` or any
+     * existing behavior. All subclasses inherit this automatically.
+     *
+     * @see https://standardschema.dev/
+     */
+    get '~standard'(): StandardSchemaV1.Props<T, T>;
+}

package/dist/src/validation/schema.js

@@ -0,0 +1,76 @@
+import { BodyType } from './body.js';
+import { Issue, ValidationError } from './error.js';
+/**
+ * The base class for all schemas.
+ */
+export class Schema extends BodyType {
+    async deserialize(stream, contentType) {
+        // Lazy import to keep this module browser-safe for yedra/schema.
+        // deserialize() is only called server-side, so the Node-specific
+        // stream utility is never resolved when bundled for the frontend.
+        const { readableToBuffer } = await import('../util/stream.js');
+        const buffer = await readableToBuffer(stream);
+        if (buffer.length === 0) {
+            return this.parse({});
+        }
+        if (contentType !== 'application/json') {
+            throw new ValidationError([
+                new Issue([], `Expected content type \`application/json\`, but got \`${contentType}\``),
+            ]);
+        }
+        const data = JSON.parse(Buffer.from(buffer).toString('utf8'));
+        return this.parse(data);
+    }
+    bodyDocs() {
+        return {
+            'application/json': {
+                schema: this.documentation(),
+            },
+        };
+    }
+    /**
+     * Whether the schema is allowed to be optional.
+     */
+    isOptional() {
+        return false;
+    }
+    /**
+     * Standard Schema V1 compliance. This allows yedra schemas to be used
+     * directly with libraries that accept Standard Schema validators
+     * (e.g. TanStack Form, TanStack Router, tRPC).
+     *
+     * This is a non-breaking addition — it does not affect `parse()` or any
+     * existing behavior. All subclasses inherit this automatically.
+     *
+     * @see https://standardschema.dev/
+     */
+    get '~standard'() {
+        return {
+            version: 1,
+            vendor: 'yedra',
+            types: {},
+            // Wraps parse() to match Standard Schema's non-throwing convention:
+            // returns { value } on success, { issues } on failure.
+            validate: (value) => {
+                try {
+                    return { value: this.parse(value) };
+                }
+                catch (error) {
+                    if (error instanceof ValidationError) {
+                        return {
+                            issues: error.issues.map((issue) => ({
+                                message: issue.message,
+                                // Convert array index strings ("0", "1") to numbers
+                                path: issue.path.map((segment) => {
+                                    const num = Number(segment);
+                                    return Number.isInteger(num) && num >= 0 ? num : segment;
+                                }),
+                            })),
+                        };
+                    }
+                    throw error;
+                }
+            },
+        };
+    }
+}

package/dist/src/validation/stream.d.ts

@@ -0,0 +1,13 @@
+import type { Readable } from 'node:stream';
+import { BodyType } from './body.js';
+declare class StreamBody extends BodyType<ReadableStream, ReadableStream> {
+    private readonly contentType;
+    constructor(contentType: string);
+    deserialize(stream: Readable, _contentType: string): Promise<ReadableStream>;
+    bodyDocs(): object;
+}
+/**
+ * Accepts a raw buffer of the specified content type, and presents it as a stream.
+ */
+export declare const stream: (contentType?: string) => StreamBody;
+export {};

package/dist/src/validation/stream.js

@@ -0,0 +1,26 @@
+import { BodyType } from './body.js';
+class StreamBody extends BodyType {
+    constructor(contentType) {
+        super();
+        this.contentType = contentType;
+    }
+    deserialize(stream, _contentType) {
+        return Promise.resolve(new ReadableStream({
+            async start(controller) {
+                for await (const chunk of stream) {
+                    controller.enqueue(chunk);
+                }
+                controller.close();
+            },
+        }));
+    }
+    bodyDocs() {
+        return {
+            [this.contentType]: {},
+        };
+    }
+}
+/**
+ * Accepts a raw buffer of the specified content type, and presents it as a stream.
+ */
+export const stream = (contentType) => new StreamBody(contentType ?? 'application/octet-stream');

package/dist/src/validation/string.d.ts

@@ -0,0 +1,29 @@
+import { ModifiableSchema } from './modifiable.js';
+declare class StringSchema extends ModifiableSchema<string> {
+    /**
+     * Set the minimum length the string is allowed to be.
+     * @param length - The minimum length.
+     */
+    min(length: number): import("./modifiable.js").RefinedSchema<string>;
+    /**
+     * Set the maximum length the string is allowed to be.
+     * @param length - The maximum length.
+     */
+    max(length: number): import("./modifiable.js").RefinedSchema<string>;
+    /**
+     * Require the string to be a valid email address.
+     */
+    email(): import("./modifiable.js").RefinedSchema<string>;
+    /**
+     * Require the string to match the specified pattern.
+     * @param pattern - A regular expression.
+     */
+    pattern(pattern: RegExp): import("./modifiable.js").RefinedSchema<string>;
+    parse(obj: unknown): string;
+    documentation(): object;
+}
+/**
+ * A schema matching a string.
+ */
+export declare const string: () => StringSchema;
+export {};

package/dist/src/validation/string.js

@@ -0,0 +1,51 @@
+import { Issue, ValidationError } from './error.js';
+import { ModifiableSchema } from './modifiable.js';
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+class StringSchema extends ModifiableSchema {
+    /**
+     * Set the minimum length the string is allowed to be.
+     * @param length - The minimum length.
+     */
+    min(length) {
+        return this.refine((s) => s.length >= length || `Must be at least ${length} characters`, { minLength: length });
+    }
+    /**
+     * Set the maximum length the string is allowed to be.
+     * @param length - The maximum length.
+     */
+    max(length) {
+        return this.refine((s) => s.length <= length || `Must be at most ${length} characters`, { maxLength: length });
+    }
+    /**
+     * Require the string to be a valid email address.
+     */
+    email() {
+        return this.refine((s) => EMAIL_REGEX.test(s) || 'Expected email address', {
+            format: 'email',
+        });
+    }
+    /**
+     * Require the string to match the specified pattern.
+     * @param pattern - A regular expression.
+     */
+    pattern(pattern) {
+        return this.refine((s) => pattern.test(s) || `Does not match pattern /${pattern.source}/`, { pattern: pattern.source });
+    }
+    parse(obj) {
+        if (typeof obj !== 'string') {
+            throw new ValidationError([
+                new Issue([], `Expected string but got ${typeof obj}`),
+            ]);
+        }
+        return obj;
+    }
+    documentation() {
+        return {
+            type: 'string',
+        };
+    }
+}
+/**
+ * A schema matching a string.
+ */
+export const string = () => new StringSchema();

package/dist/src/validation/union.d.ts

@@ -0,0 +1,16 @@
+import type { Typeof } from './body.js';
+import { ModifiableSchema } from './modifiable.js';
+import type { Schema } from './schema.js';
+declare class UnionSchema<T extends [...Schema<unknown>[]]> extends ModifiableSchema<Typeof<T[number]>> {
+    private readonly options;
+    constructor(options: T);
+    parse(obj: unknown): Typeof<T[number]>;
+    documentation(): object;
+}
+/**
+ * A schema that matches one of multiple other schemas. Similar to `y.enum`,
+ * expect that this requires real schemas instead of just strings or numbers.
+ * @param options - The different possible schemas.
+ */
+export declare const union: <T extends [...Schema<unknown>[]]>(...options: T) => UnionSchema<T>;
+export {};

package/dist/src/validation/union.js

@@ -0,0 +1,36 @@
+import { ValidationError } from './error.js';
+import { ModifiableSchema } from './modifiable.js';
+class UnionSchema extends ModifiableSchema {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    parse(obj) {
+        const issues = [];
+        for (const option of this.options) {
+            try {
+                return option.parse(obj);
+            }
+            catch (error) {
+                if (error instanceof ValidationError) {
+                    issues.push(...error.issues);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw new ValidationError(issues);
+    }
+    documentation() {
+        return {
+            anyOf: this.options.map((option) => option.documentation()),
+        };
+    }
+}
+/**
+ * A schema that matches one of multiple other schemas. Similar to `y.enum`,
+ * expect that this requires real schemas instead of just strings or numbers.
+ * @param options - The different possible schemas.
+ */
+export const union = (...options) => new UnionSchema(options);

package/dist/src/validation/unknown.d.ts

@@ -0,0 +1,10 @@
+import { ModifiableSchema } from './modifiable.js';
+declare class UnknownSchema extends ModifiableSchema<unknown> {
+    parse(obj: unknown): unknown;
+    documentation(): object;
+}
+/**
+ * A schema matching anything.
+ */
+export declare const unknown: () => UnknownSchema;
+export {};

package/dist/src/validation/unknown.js

@@ -0,0 +1,13 @@
+import { ModifiableSchema } from './modifiable.js';
+class UnknownSchema extends ModifiableSchema {
+    parse(obj) {
+        return obj;
+    }
+    documentation() {
+        return {};
+    }
+}
+/**
+ * A schema matching anything.
+ */
+export const unknown = () => new UnknownSchema();

package/dist/src/validation/uuid.d.ts

@@ -0,0 +1,11 @@
+import { ModifiableSchema } from './modifiable.js';
+declare class UuidSchema extends ModifiableSchema<string> {
+    parse(obj: unknown): string;
+    documentation(): object;
+}
+/**
+ * A schema matching a universally unique identifier UUID
+ * of version 4.
+ */
+export declare const uuid: () => UuidSchema;
+export {};

package/dist/src/validation/uuid.js

@@ -0,0 +1,23 @@
+import { validate, version } from 'uuid';
+import { Issue, ValidationError } from './error.js';
+import { ModifiableSchema } from './modifiable.js';
+class UuidSchema extends ModifiableSchema {
+    parse(obj) {
+        if (typeof obj !== 'string' || !validate(obj) || version(obj) !== 4) {
+            throw new ValidationError([
+                new Issue([], `Expected uuid but got ${typeof obj}`),
+            ]);
+        }
+        return obj;
+    }
+    documentation() {
+        return {
+            type: 'string',
+        };
+    }
+}
+/**
+ * A schema matching a universally unique identifier UUID
+ * of version 4.
+ */
+export const uuid = () => new UuidSchema();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "yedra",
-	"version": "0.20.11",
+	"version": "0.20.13",
 	"repository": "github:0codekit/yedra",
 	"main": "dist/index.js",
 	"exports": {
@@ -17,9 +17,8 @@
 		"@biomejs/biome": "^2.4.5",
 		"@types/bun": "^1.3.10",
 		"@types/node": "^25.3.3",
-		"@types/uuid": "^11.0.0",
 		"@types/ws": "^8.18.1",
-		"typescript": "^5.9.3"
+		"typescript": "^6.0.3"
 	},
 	"bugs": "https://github.com/0codekit/yedra/issues",
 	"contributors": [
@@ -47,7 +46,7 @@
 		"@opentelemetry/api": "^1.9.0",
 		"@standard-schema/spec": "^1.1.0",
 		"mime": "^4.1.0",
-		"uuid": "^13.0.0",
+		"uuid": "^14.0.0",
 		"ws": "^8.19.0"
 	}
 }