@tstdl/base 0.91.12 → 0.91.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.12",
+  "version": "0.91.14",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -111,7 +111,7 @@
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.24"
+    "type-fest": "4.26"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -134,8 +134,8 @@
     "typescript": "5.5"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.14",
-    "@koa/router": "^12.0",
+    "@elastic/elasticsearch": "^8.15",
+    "@koa/router": "^13.0",
     "@tstdl/angular": "^0.91",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",

package/pdf/pdf.service.js

@@ -61,8 +61,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { execFile as execFileCallback } from 'node:child_process';
 import { access, readFile, unlink, writeFile } from 'node:fs/promises';
-import { promisify } from 'node:util';
 import { tmpdir } from 'node:os';
+import { promisify } from 'node:util';
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';

package/process/spawn.d.ts

@@ -0,0 +1,15 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
+    process: ChildProcessWithoutNullStreams;
+    stderr: ReadableStream<Uint8Array>;
+    write(chunk: ReadableStream<Uint8Array> | Uint8Array | string): Promise<void>;
+    readOutputBytes(): Promise<Uint8Array>;
+    readOutput(): Promise<string>;
+    readErrBytes(): Promise<Uint8Array>;
+    readErr(): Promise<string>;
+    wait(): Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+};
+export declare function spawnCommand(command: string, args: string[]): Promise<SpawnCommandResult>;

package/process/spawn.js

@@ -0,0 +1,55 @@
+import { dynamicImport } from '../import.js';
+import { decodeTextStream, encodeUtf8Stream } from '../utils/encoding.js';
+import { readBinaryStream, readTextStream } from '../utils/stream/stream-reader.js';
+import { toReadableStream } from '../utils/stream/to-readable-stream.js';
+import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+export async function spawnCommand(command, args) {
+    const { spawn } = await dynamicImport('node:child_process');
+    const { Readable, Writable } = await dynamicImport('node:stream');
+    const process = spawn(command, args, { stdio: 'pipe' });
+    await Promise.race([
+        new Promise((resolve) => process.on('spawn', resolve)),
+        new Promise((_, reject) => process.on('error', reject))
+    ]);
+    const readable = Readable.toWeb(process.stdout);
+    const writable = Writable.toWeb(process.stdin);
+    const stderr = Readable.toWeb(process.stderr);
+    async function write(data) {
+        if (isReadableStream(data)) {
+            await data.pipeTo(writable);
+        }
+        else if (isUint8Array(data)) {
+            await toReadableStream(data).pipeTo(writable);
+        }
+        else if (isString(data)) {
+            await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable);
+        }
+    }
+    async function readOutputBytes() {
+        return readBinaryStream(readable);
+    }
+    async function readOutput() {
+        return readTextStream(readable.pipeThrough(decodeTextStream()));
+    }
+    async function readErrBytes() {
+        return readBinaryStream(stderr);
+    }
+    async function readErr() {
+        return readTextStream(stderr.pipeThrough(decodeTextStream()));
+    }
+    const signalPromise = new Promise((resolve) => process.on('close', (code, signal) => resolve({ code, signal })));
+    return {
+        process,
+        readable,
+        writable,
+        stderr,
+        write,
+        readOutputBytes,
+        readOutput,
+        readErrBytes,
+        readErr,
+        async wait() {
+            return signalPromise;
+        },
+    };
+}

package/schema/schema.d.ts

@@ -23,6 +23,7 @@ export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | N
 export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
 export declare const OPTIONAL: unique symbol;
 export declare abstract class Schema<T = unknown> {
+    abstract readonly name: string;
     readonly [OPTIONAL]: boolean;
     /**
      * Test an unknown value to see whether it corresponds to the schema.

package/schema/schema.error.d.ts

@@ -13,6 +13,7 @@ export declare class SchemaError extends CustomError implements ErrorExtraInfo {
     readonly path: string;
     readonly details?: UndefinableJson;
     readonly inner?: OneOrMany<SchemaError>;
+    readonly innerMessages?: string[];
     constructor(message: string, options: SchemaErrorOptions, cause?: any);
     static expectedButGot(expected: OneOrMany<string | AbstractConstructor>, got: string, path: string | JsonPath, options?: TypedOmit<SchemaErrorOptions, 'path'> & {
         customMessage?: string;

package/schema/schema.error.js

@@ -6,6 +6,7 @@ export class SchemaError extends CustomError {
     path;
     details;
     inner;
+    innerMessages;
     constructor(message, options, cause) {
         super({ message, cause: cause ?? options.cause, fast: options.fast });
         this.path = isString(options.path) ? options.path : options.path.path;
@@ -15,6 +16,7 @@ export class SchemaError extends CustomError {
                     ? options.inner[0]
                     : options.inner
                 : options.inner;
+            this.innerMessages = toArray(options.inner).flatMap((inner) => [`${inner.path}: ${inner.message}`, ...(inner.innerMessages ?? [])]);
         }
         if (isNotNullOrUndefined(options.details)) {
             this.details = options.details;

package/schema/schemas/any.d.ts

@@ -1,6 +1,7 @@
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestResult } from '../schema.js';
 export declare class AnySchema extends Schema<any> {
+    readonly name = "any";
     _test(value: any): SchemaTestResult<any>;
 }
 export declare function any(): AnySchema;

package/schema/schemas/any.js

@@ -1,6 +1,7 @@
 import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 export class AnySchema extends Schema {
+    name = 'any';
     _test(value) {
         return { valid: true, value };
     }

package/schema/schemas/array.d.ts

@@ -3,6 +3,7 @@ import type { TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class ArraySchema<T> extends Schema<T[]> {
+    readonly name: string;
     readonly itemSchema: Schema<T>;
     constructor(itemSchema: SchemaTestable<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;

package/schema/schemas/array.js

@@ -5,10 +5,12 @@ import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class ArraySchema extends Schema {
+    name;
     itemSchema;
     constructor(itemSchema) {
         super();
         this.itemSchema = schemaTestableToSchema(itemSchema);
+        this.name = `Array[${this.itemSchema.name}]`;
     }
     _test(value, path, options) {
         if (!isArray(value)) {

package/schema/schemas/bigint.d.ts

@@ -3,6 +3,7 @@ import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import type { SchemaPropertyDecorator } from '../decorators/types.js';
 import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class BigIntSchema extends Schema<bigint> {
+    readonly name = "bigint";
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<bigint>;
 }
 export declare function bigint(): BigIntSchema;

package/schema/schemas/bigint.js

@@ -4,6 +4,7 @@ import { typeOf } from '../../utils/type-of.js';
 import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 export class BigIntSchema extends Schema {
+    name = 'bigint';
     _test(value, path, options) {
         if (isBigInt(value)) {
             return { valid: true, value };

package/schema/schemas/boolean.d.ts

@@ -4,6 +4,7 @@ import type { SchemaTestOptions, SchemaTestResult } from '../schema.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type BooleanSchemaOptions = SimpleSchemaOptions;
 export declare class BooleanSchema extends SimpleSchema<boolean> {
+    readonly name = "boolean";
     constructor(options?: BooleanSchemaOptions);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<boolean>;
 }

package/schema/schemas/boolean.js

@@ -4,6 +4,7 @@ import { typeOf } from '../../utils/type-of.js';
 import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class BooleanSchema extends SimpleSchema {
+    name = 'boolean';
     constructor(options) {
         super('boolean', isBoolean, options, {
             coercers: {

package/schema/schemas/date.d.ts

@@ -4,6 +4,7 @@ export type DateSchemaOptions = SimpleSchemaOptions & {
     integer?: boolean;
 };
 export declare class DateSchema extends SimpleSchema<globalThis.Date> {
+    readonly name = "date";
     constructor(options?: DateSchemaOptions);
 }
 export declare function date(options?: DateSchemaOptions): DateSchema;

package/schema/schemas/date.js

@@ -3,6 +3,7 @@ import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class DateSchema extends SimpleSchema {
+    name = 'date';
     constructor(options) {
         super('date', isValidDate, options, {
             coercers: {

package/schema/schemas/defaulted.d.ts

@@ -2,6 +2,7 @@ import type { JsonPath } from '../../json-path/json-path.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class DefaultSchema<T, D> extends Schema<T | D> {
+    readonly name: string;
     readonly schema: Schema<T>;
     readonly defaultValue: D;
     constructor(schema: SchemaTestable<T>, defaultValue: D);

package/schema/schemas/defaulted.js

@@ -3,12 +3,14 @@ import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class DefaultSchema extends Schema {
+    name;
     schema;
     defaultValue;
     constructor(schema, defaultValue) {
         super();
         this.schema = schemaTestableToSchema(schema);
         this.defaultValue = defaultValue;
+        this.name = `Defaulted[${this.schema.name}]`;
     }
     _test(value, path, options) {
         if (isNullOrUndefined(value)) {

package/schema/schemas/enumeration.d.ts

@@ -4,6 +4,7 @@ import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type EnumerationSchemaOptions = SimpleSchemaOptions;
 export declare class EnumerationSchema<T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
     #private;
+    readonly name: string;
     readonly enumeration: EnumerationType;
     constructor(enumeration: T, options?: EnumerationSchemaOptions);
 }

package/schema/schemas/enumeration.js

@@ -4,6 +4,7 @@ import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class EnumerationSchema extends SimpleSchema {
     #allowedValuesSet;
+    name;
     enumeration;
     constructor(enumeration, options) {
         const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
@@ -17,6 +18,7 @@ export class EnumerationSchema extends SimpleSchema {
         });
         this.enumeration = enumeration;
         this.#allowedValuesSet = new Set(allowedValues);
+        this.name = `Enumeration[${allowedValuesString}]`;
     }
 }
 export function enumeration(enumeration, options) {

package/schema/schemas/function.d.ts

@@ -2,6 +2,7 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type FunctionSchemaOptions = SimpleSchemaOptions;
 export declare class FunctionSchema extends SimpleSchema<Function> {
+    readonly name = "function";
     constructor(options?: FunctionSchemaOptions);
 }
 export declare function func(): FunctionSchema;

package/schema/schemas/function.js

@@ -2,6 +2,7 @@ import { isFunction } from '../../utils/type-guards.js';
 import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class FunctionSchema extends SimpleSchema {
+    name = 'function';
     constructor(options) {
         super('function', isFunction, options);
     }

package/schema/schemas/instance.d.ts

@@ -3,6 +3,7 @@ import type { AbstractConstructor } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
+    readonly name: string;
     readonly type: T;
     constructor(type: T);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>>;

package/schema/schemas/instance.js

@@ -3,10 +3,12 @@ import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { Schema } from '../schema.js';
 export class InstanceSchema extends Schema {
+    name;
     type;
     constructor(type) {
         super();
         this.type = type;
+        this.name = `Instance[${type.name}]`;
     }
     _test(value, path, options) {
         if (value instanceof this.type) {

package/schema/schemas/literal.d.ts

@@ -2,6 +2,7 @@ import type { JsonPath } from '../../json-path/json-path.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class LiteralSchema<const T> extends Schema<T> {
+    readonly name: string;
     readonly value: T;
     constructor(value: T);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;

package/schema/schemas/literal.js

@@ -4,10 +4,12 @@ import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { Schema } from '../schema.js';
 export class LiteralSchema extends Schema {
+    name;
     value;
     constructor(value) {
         super();
         this.value = value;
+        this.name = `Literal[${String(value)}]`;
     }
     _test(value, path, options) {
         if (value === this.value) {

package/schema/schemas/never.d.ts

@@ -1,6 +1,7 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class NeverSchema extends Schema<never> {
+    readonly name = "never";
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<never>;
 }
 export declare function never(): NeverSchema;

package/schema/schemas/never.js

@@ -2,6 +2,7 @@ import { SchemaError } from '../../schema/schema.error.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Schema } from '../schema.js';
 export class NeverSchema extends Schema {
+    name = 'never';
     _test(value, path, options) {
         return { valid: false, error: SchemaError.expectedButGot('never', typeOf(value), path, { fast: options.fastErrors }) };
     }

package/schema/schemas/nullable.d.ts

@@ -3,6 +3,7 @@ import type { TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class NullableSchema<T> extends Schema<T | null> {
+    readonly name: string;
     readonly schema: Schema<T>;
     constructor(schema: SchemaTestable<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;

package/schema/schemas/nullable.js

@@ -3,6 +3,7 @@ import { createSchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class NullableSchema extends Schema {
+    name;
     schema;
     constructor(schema) {
         if ((schema instanceof NullableSchema) && (schema == schema.schema)) {
@@ -10,6 +11,7 @@ export class NullableSchema extends Schema {
         }
         super();
         this.schema = schemaTestableToSchema(schema);
+        this.name = `Nullable[${this.schema.name}]`;
     }
     _test(value, path, options) {
         if (isNull(value)) {

package/schema/schemas/number.d.ts

@@ -4,6 +4,7 @@ export type NumberSchemaOptions = SimpleSchemaOptions & {
     integer?: boolean;
 };
 export declare class NumberSchema extends SimpleSchema<number> {
+    readonly name = "number";
     constructor(options?: NumberSchemaOptions);
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;

package/schema/schemas/number.js

@@ -3,6 +3,7 @@ import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class NumberSchema extends SimpleSchema {
+    name = 'number';
     constructor(options) {
         super('number', isNumber, options, {
             coercers: {

package/schema/schemas/object.d.ts

@@ -16,6 +16,7 @@ export type NormalizedObjectSchemaProperties<T extends Record> = {
     [P in keyof T]-?: Schema<T[P]>;
 };
 export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey = PropertyKey, V = unknown> = {
+    name?: string;
     mask?: boolean | null;
     unknownProperties?: SchemaTestable<V> | null;
     unknownPropertiesKey?: SchemaTestable<K> | null;
@@ -34,6 +35,7 @@ export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflect
 export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
     private readonly propertyKeys;
     private readonly allowUnknownProperties;
+    readonly name: string;
     readonly properties: NormalizedObjectSchemaProperties<T>;
     readonly mask: boolean | null;
     readonly unknownProperties: Schema | null;

package/schema/schemas/object.js

@@ -16,6 +16,7 @@ export const tryGetSchemaFromReflection = memoizeSingle(_tryGetSchemaFromReflect
 export class ObjectSchema extends Schema {
     propertyKeys;
     allowUnknownProperties;
+    name;
     properties;
     mask;
     unknownProperties;
@@ -30,6 +31,7 @@ export class ObjectSchema extends Schema {
         this.factory = options.factory ?? null;
         this.allowUnknownProperties = isNotNull(this.unknownProperties) || isNotNull(this.unknownPropertiesKey);
         this.propertyKeys = new Set(objectKeys(properties));
+        this.name = options.name ?? 'Object';
     }
     _test(value, path, options) {
         if (!isObject(value)) {
@@ -82,6 +84,7 @@ export function record(key, value, options) {
 export function assign(...schemasOrTypes) {
     const schemas = schemasOrTypes.map(getObjectSchema);
     return object(schemas.reduce((result, schema) => ({ ...result, ...schema.properties }), {}), {
+        name: schemas.at(-1)?.name,
         mask: schemas.findLast((schema) => isNotNull(schema.mask))?.mask,
         unknownProperties: schemas.findLast((schema) => isNotNull(schema.unknownProperties))?.unknownProperties,
         unknownPropertiesKey: schemas.findLast((schema) => isNotNull(schema.unknownPropertiesKey))?.unknownPropertiesKey
@@ -137,6 +140,7 @@ function _tryGetSchemaFromReflection(type) {
         return schemaTestableToSchema(typeData.schema);
     }
     const schema = object(getObjectSchemaPropertiesFromReflection(metadata, type), {
+        name: type.name,
         factory: isDefined(typeData.factory) ? typeData.factory : { type: type },
         mask: typeData.mask,
         unknownProperties: typeData.unknownProperties,

package/schema/schemas/one-or-many.d.ts

@@ -4,6 +4,7 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type OneOrMany<T> = OneOrManyType<T>;
 export declare class OneOrManySchema<T> extends Schema<T | T[]> {
+    readonly name: string;
     readonly schema: Schema<T | T[]>;
     constructor(schema: SchemaTestable<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | T[]>;

package/schema/schemas/one-or-many.js

@@ -4,11 +4,13 @@ import { schemaTestableToSchema } from '../testable.js';
 import { array } from './array.js';
 import { union } from './union.js';
 export class OneOrManySchema extends Schema {
+    name;
     schema;
     constructor(schema) {
         super();
         const oneSchema = schemaTestableToSchema(schema);
         this.schema = union(oneSchema, array(oneSchema));
+        this.name = `OneOrMany[${oneSchema.name}]`;
     }
     _test(value, path, options) {
         return this.schema._test(value, path, options);

package/schema/schemas/optional.d.ts

@@ -3,6 +3,7 @@ import type { TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { type OPTIONAL, Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class OptionalSchema<T> extends Schema<T | undefined> {
+    readonly name: string;
     readonly [OPTIONAL]: true;
     readonly schema: Schema<T>;
     constructor(schema: SchemaTestable<T>);

package/schema/schemas/optional.js

@@ -3,6 +3,7 @@ import { createSchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class OptionalSchema extends Schema {
+    name;
     schema;
     constructor(schema) {
         if ((schema instanceof OptionalSchema) && (schema == schema.schema)) {
@@ -10,6 +11,7 @@ export class OptionalSchema extends Schema {
         }
         super();
         this.schema = schemaTestableToSchema(schema);
+        this.name = `Optional[${this.schema.name}]`;
     }
     _test(value, path, options) {
         if (isUndefined(value)) {

package/schema/schemas/readable-stream.d.ts

@@ -2,6 +2,7 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type ReadableStreamSchemaOptions = SimpleSchemaOptions;
 export declare class ReadableStreamSchema extends SimpleSchema<ReadableStream> {
+    readonly name = "ReadableStream";
     constructor(options?: ReadableStreamSchemaOptions);
 }
 export declare function readableStream(options?: ReadableStreamSchemaOptions): ReadableStreamSchema;

package/schema/schemas/readable-stream.js

@@ -2,6 +2,7 @@ import { isReadableStream } from '../../utils/type-guards.js';
 import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class ReadableStreamSchema extends SimpleSchema {
+    name = 'ReadableStream';
     constructor(options) {
         super('ReadableStream', isReadableStream, options);
     }

package/schema/schemas/regexp.d.ts

@@ -2,6 +2,7 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type RegExpSchemaOptions = SimpleSchemaOptions;
 export declare class RegExpSchema extends SimpleSchema<RegExp> {
+    readonly name = "RegExp";
     constructor(options?: RegExpSchemaOptions);
 }
 export declare function regExp(options?: RegExpSchemaOptions): RegExpSchema;

package/schema/schemas/regexp.js

@@ -3,6 +3,7 @@ import { Property } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class RegExpSchema extends SimpleSchema {
+    name = 'RegExp';
     constructor(options) {
         super('RegExp', isRegExp, options, {
             coercers: {

package/schema/schemas/string.d.ts

@@ -4,6 +4,7 @@ export type StringSchemaOptions = SimpleSchemaOptions & {
     pattern?: RegExp | string;
 };
 export declare class StringSchema extends SimpleSchema<string> {
+    readonly name = "string";
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;

package/schema/schemas/string.js

@@ -2,6 +2,7 @@ import { isDefined, isRegExp, isString } from '../../utils/type-guards.js';
 import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class StringSchema extends SimpleSchema {
+    name = 'string';
     constructor(options) {
         const pattern = isDefined(options?.pattern) ? isString(options.pattern) ? RegExp(options.pattern, 'u') : isRegExp(options.pattern) ? options.pattern : undefined : undefined;
         super('string', isString, options, {

package/schema/schemas/symbol.d.ts

@@ -2,6 +2,7 @@ import type { JsonPath } from '../../json-path/json-path.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class SymbolSchema extends Schema<symbol> {
+    readonly name = "symbol";
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<symbol>;
 }
 export declare function symbol(): SymbolSchema;

package/schema/schemas/symbol.js

@@ -4,6 +4,7 @@ import { typeOf } from '../../utils/type-of.js';
 import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 export class SymbolSchema extends Schema {
+    name = 'symbol';
     _test(value, path, options) {
         if (isSymbol(value)) {
             return { valid: true, value };

package/schema/schemas/transform.d.ts

@@ -1,9 +1,10 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class TransformSchema<I, O> extends Schema<O> {
+    readonly name: string;
     readonly schema: Schema<I>;
     readonly transformFn: (value: I) => O;
-    constructor(schema: Schema<I>, transformFn: (value: I) => O);
+    constructor(schema: SchemaTestable<I>, transformFn: (value: I) => O);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<O>;
 }
 export declare function transform<I, O>(schema: Schema<I>, transformFn: (value: I) => O): TransformSchema<I, O>;

package/schema/schemas/transform.js

@@ -1,11 +1,14 @@
 import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
 export class TransformSchema extends Schema {
+    name;
     schema;
     transformFn;
     constructor(schema, transformFn) {
         super();
-        this.schema = schema;
+        this.schema = schemaTestableToSchema(schema);
         this.transformFn = transformFn;
+        this.name = `Transform[${schema.name}]`;
     }
     _test(value, path, options) {
         const result = this.schema._test(value, path, options);

package/schema/schemas/uint8-array.d.ts

@@ -7,6 +7,7 @@ export type Uint8ArraySchemaOptions = SimpleSchemaOptions & {
     maximumLength?: number;
 };
 export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
+    readonly name = "Uint8Array";
     readonly options: Uint8ArraySchemaOptions;
     constructor(options?: Uint8ArraySchemaOptions);
 }

package/schema/schemas/uint8-array.js

@@ -2,6 +2,7 @@ import { isDefined, isUint8Array } from '../../utils/type-guards.js';
 import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class Uint8ArraySchema extends SimpleSchema {
+    name = 'Uint8Array';
     options;
     constructor(options) {
         super('Uint8Array', isUint8Array, options, {

package/schema/schemas/union.d.ts

@@ -3,6 +3,7 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 type UnionSchemaType<T extends [SchemaTestable, ...SchemaTestable[]]> = T[number] extends SchemaTestable<infer V> ? V : never;
 export declare class UnionSchema<T extends [SchemaTestable, ...SchemaTestable[]]> extends Schema<UnionSchemaType<T>> {
+    readonly name: string;
     readonly schemas: {
         [P in keyof T]: T[P] extends Schema ? T[P] : Schema<SchemaOutput<T[P]>>;
     };

package/schema/schemas/union.js

@@ -1,22 +1,31 @@
 import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
 import { Schema } from '../schema.js';
 import { isSchemaTestable, schemaTestableToSchema } from '../testable.js';
 export class UnionSchema extends Schema {
+    name;
     schemas;
     constructor(schemas) {
         super();
-        this.schemas = schemas.map((schema) => schemaTestableToSchema(schema));
+        this.schemas = schemas.flatMap((testable) => {
+            const schema = schemaTestableToSchema(testable);
+            if (schema instanceof UnionSchema) {
+                return schema.schemas;
+            }
+            return schema;
+        });
+        this.name = `Union[${this.schemas.map((schema) => schema.name).join(', ')}]`;
     }
     _test(value, path, options) {
-        let firstInvalidResult;
+        const errors = [];
         for (const schema of this.schemas) {
             const result = schema._test(value, path, options);
             if (result.valid) {
                 return result;
             }
-            firstInvalidResult ??= result;
+            errors.push(result.error);
         }
-        return firstInvalidResult;
+        return { valid: false, error: new SchemaError(`None of the schemas [${this.schemas.map((schema) => schema.name).join(', ')}] matched. See inner for details.`, { path, inner: errors, fast: options.fastErrors }) };
     }
 }
 export function union(...schemas) {

package/schema/schemas/unknown.d.ts

@@ -1,6 +1,7 @@
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestResult } from '../schema.js';
 export declare class UnknownSchema extends Schema<unknown> {
+    readonly name = "unknown";
     _test(value: unknown): SchemaTestResult<unknown>;
 }
 export declare function unknown(): UnknownSchema;

package/schema/schemas/unknown.js

@@ -1,6 +1,7 @@
 import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 export class UnknownSchema extends Schema {
+    name = 'unknown';
     _test(value) {
         return { valid: true, value };
     }

package/schema/testable.js

@@ -5,8 +5,10 @@ import { boolean } from './schemas/boolean.js';
 import { func } from './schemas/function.js';
 import { number } from './schemas/number.js';
 import { getSchemaFromReflection } from './schemas/object.js';
+import { readableStream } from './schemas/readable-stream.js';
 import { string } from './schemas/string.js';
 import { symbol } from './schemas/symbol.js';
+import { uint8Array } from './schemas/uint8-array.js';
 export function schemaTestableToSchema(testable) {
     if (testable instanceof Schema) {
         return testable;
@@ -24,6 +26,10 @@ export function schemaTestableToSchema(testable) {
             return symbol();
         case Function:
             return func();
+        case Uint8Array:
+            return uint8Array();
+        case ReadableStream:
+            return readableStream();
         default:
             return getSchemaFromReflection(testable);
     }

package/utils/encoding.d.ts

@@ -15,13 +15,13 @@ export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array>;
  * @param encoding encoding, defaults to utf8
  * @returns decoded string
  */
-export declare function decodeText(buffer: BinaryData, encoding?: string): string;
+export declare function decodeText(buffer: BinaryData, encoding?: string, options?: TextDecoderOptions): string;
 /**
  * Transforms binary stream to string stream
  * @param encoding encoding, defaults to utf8
  * @returns stream of decoded string
  */
-export declare function decodeTextStream(encoding?: string): TransformStream<BinaryData, string>;
+export declare function decodeTextStream(encoding?: string, options?: TextDecoderOptions): TransformStream<BinaryData, string>;
 /**
  * Encodes buffer to hex
  * @param buffer buffer to encode

package/utils/encoding.js

@@ -25,8 +25,8 @@ export function encodeUtf8Stream() {
  * @param encoding encoding, defaults to utf8
  * @returns decoded string
  */
-export function decodeText(buffer, encoding) {
-    const decoder = new TextDecoder(encoding, { fatal: true });
+export function decodeText(buffer, encoding, options) {
+    const decoder = new TextDecoder(encoding, options);
     return decoder.decode(buffer);
 }
 /**
@@ -34,8 +34,8 @@ export function decodeText(buffer, encoding) {
  * @param encoding encoding, defaults to utf8
  * @returns stream of decoded string
  */
-export function decodeTextStream(encoding) {
-    return new TextDecoderStream(encoding, { fatal: true });
+export function decodeTextStream(encoding, options) {
+    return new TextDecoderStream(encoding, options);
 }
 /**
  * Encodes buffer to hex

package/utils/stream/index.d.ts

@@ -6,3 +6,4 @@ export * from './slice.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
 export * from './to-bytes-stream.js';
+export * from './to-readable-stream.js';

package/utils/stream/index.js

@@ -6,3 +6,4 @@ export * from './slice.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
 export * from './to-bytes-stream.js';
+export * from './to-readable-stream.js';

package/utils/stream/stream-reader.d.ts

@@ -7,4 +7,4 @@ export type ReadBinaryStreamOptions = {
     onLengthSubceed?: 'error' | 'close' | 'leave-open';
 };
 export declare function readBinaryStream(iterableOrStream: AnyIterable<ArrayBufferView> | ReadableStream<ArrayBufferView>, { length, onLengthExceed, onLengthSubceed }?: ReadBinaryStreamOptions): Promise<Uint8Array>;
-export declare function readTextStream(iterableOrStream: AnyIterable<string> | ReadableStream<string>): Promise<string>;
+export declare function readTextStream(iterableOrStream: AsyncIterable<string> | ReadableStream<string>): Promise<string>;

package/utils/stream/stream-reader.js

@@ -1,6 +1,7 @@
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { MaxBytesExceededError } from '../../errors/max-bytes-exceeded.error.js';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { isAsyncIterable } from '../async-iterable-helpers/is-async-iterable.js';
 import { concatArrayBufferViews } from '../binary.js';
 import { isDefined, isReadableStream } from '../type-guards.js';
 import { getReadableStreamFromIterable, getReadableStreamIterable } from './readable-stream-adapter.js';
@@ -77,7 +78,7 @@ export async function readBinaryStream(iterableOrStream, { length, onLengthExcee
     return concatArrayBufferViews(views, Uint8Array, totalLength);
 }
 export async function readTextStream(iterableOrStream) {
-    const iterable = isReadableStream(iterableOrStream) ? getReadableStreamIterable(iterableOrStream) : iterableOrStream;
+    const iterable = isAsyncIterable(iterableOrStream) ? iterableOrStream : getReadableStreamIterable(iterableOrStream);
     let text = '';
     for await (const chunk of iterable) {
         text += chunk;

package/utils/stream/to-readable-stream.d.ts

@@ -0,0 +1 @@
+export declare function toReadableStream<T>(value: T): ReadableStream<T>;

package/utils/stream/to-readable-stream.js

@@ -0,0 +1,8 @@
+export function toReadableStream(value) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(value);
+            controller.close();
+        }
+    });
+}