@tstdl/base 0.92.8 → 0.92.9

package/schema/decorators/utils.js

@@ -1,9 +1,28 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { createPropertyOrAccessorDecorator } from '../../reflection/index.js';
-import { filterUndefinedObjectProperties } from '../../utils/object/object.js';
-export function createSchemaPropertyDecorator(data = {}) {
-    return createPropertyOrAccessorDecorator({
-        data: { schema: filterUndefinedObjectProperties(data) },
-        mergeData: true
-    });
+import { isDefined, isFunction, isNullOrUndefined, isUndefined } from '../../utils/type-guards.js';
+import { array } from '../schemas/array.js';
+import { nullable } from '../schemas/nullable.js';
+import { optional } from '../schemas/optional.js';
+import { schemaTestableToSchema } from '../testable.js';
+export function schemaReflectionDataToSchema(reflectionData, fallbackType, source) {
+    if (isUndefined(reflectionData?.schema) && (fallbackType == Object)) {
+        throw new Error(`Schema of property "${String(source.key)}" on type ${source.type.name} is inferred as Object. This is most likely unwanted and happens if the property is defined as partial or the type is an union. Use an explicit @Property(Object) if this is wanted.`);
+    }
+    let propertySchema = isDefined(reflectionData?.schema) ? reflectionData.schema(reflectionData) : fallbackType;
+    if (isNullOrUndefined(propertySchema)) {
+        throw new Error(`Could not infer schema for property "${String(source.key)}" on type ${source.type.name}. This happens if neither explicit @Property(type) is used nor reflection metadata is available.`);
+    }
+    if (isFunction(propertySchema)) {
+        propertySchema = schemaTestableToSchema(propertySchema, { description: reflectionData?.description, example: reflectionData?.example });
+    }
+    if (reflectionData?.array == true) {
+        propertySchema = array(propertySchema);
+    }
+    if (reflectionData?.nullable == true) {
+        propertySchema = nullable(propertySchema);
+    }
+    if (reflectionData?.optional == true) {
+        propertySchema = optional(propertySchema);
+    }
+    return propertySchema;
 }

package/schema/schema.d.ts

@@ -22,9 +22,9 @@ type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, Stri
 export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
 export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
 export declare const OPTIONAL: unique symbol;
-export type SchemaOptions<T> = {
+export type SchemaOptions<_T> = {
     description?: string | null;
-    example?: T | undefined;
+    example?: any;
 };
 export declare abstract class Schema<T = unknown> {
     readonly [OPTIONAL]: boolean;

package/schema/schemas/any.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestResult } from '../schema.js';
 export type AnySchemaOptions = SchemaOptions<any>;
 export declare class AnySchema extends Schema<any> {
@@ -6,4 +6,4 @@ export declare class AnySchema extends Schema<any> {
     _test(value: any): SchemaTestResult<any>;
 }
 export declare function any(options?: AnySchemaOptions): AnySchema;
-export declare function Any(options?: AnySchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Any(options?: AnySchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/array.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { TypedOmit } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 import type { Coercible } from '../types.js';
 export type ArraySchemaOptions<T> = SchemaOptions<T[]> & Coercible & {
@@ -17,4 +17,4 @@ export declare class ArraySchema<T> extends Schema<T[]> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
 }
 export declare function array<T>(schema: SchemaTestable<T>, options?: ArraySchemaOptions<T>): ArraySchema<T>;
-export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions<unknown> & TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;
+export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions<unknown> & TypedOmit<SchemaDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/bigint.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions } from '../decorators/index.js';
 import type { SchemaPropertyDecorator } from '../decorators/types.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type BigIntSchemaOptions = SimpleSchemaOptions<bigint>;
@@ -7,4 +7,4 @@ export declare class BigIntSchema extends SimpleSchema<bigint> {
     constructor(options?: BigIntSchemaOptions);
 }
 export declare function bigint(options?: BigIntSchemaOptions): BigIntSchema;
-export declare function BigIntProperty(options?: BigIntSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function BigIntProperty(options?: BigIntSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type BooleanSchemaOptions = SimpleSchemaOptions<boolean>;
 export declare class BooleanSchema extends SimpleSchema<boolean> {
@@ -6,4 +6,4 @@ export declare class BooleanSchema extends SimpleSchema<boolean> {
     constructor(options?: BooleanSchemaOptions);
 }
 export declare function boolean(options?: BooleanSchemaOptions): BooleanSchema;
-export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/date.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type DateSchemaOptions = SimpleSchemaOptions<globalThis.Date> & {
     integer?: boolean;
@@ -8,4 +8,4 @@ export declare class DateSchema extends SimpleSchema<globalThis.Date> {
     constructor(options?: DateSchemaOptions);
 }
 export declare function date(options?: DateSchemaOptions): DateSchema;
-export declare function DateProperty(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;
+export declare function DateProperty(options?: SchemaDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/defaulted.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type DefaultSchemaOptions<T, D> = SchemaOptions<T | D>;
 export declare class DefaultSchema<T, D> extends Schema<T | D> {
@@ -10,4 +10,4 @@ export declare class DefaultSchema<T, D> extends Schema<T | D> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | D>;
 }
 export declare function defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D>): DefaultSchema<T, D>;
-export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/deferred.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class DeferredSchema<T extends SchemaTestable> extends Schema<SchemaOutput<T>> {
     readonly name: string;
@@ -9,4 +9,4 @@ export declare class DeferredSchema<T extends SchemaTestable> extends Schema<Sch
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<SchemaOutput<T>>;
 }
 export declare function deferred<T extends SchemaTestable>(schema: () => T): DeferredSchema<T>;
-export declare function Deferred(schema: () => SchemaTestable, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Deferred(schema: () => SchemaTestable, options?: SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/enumeration.d.ts

@@ -1,5 +1,5 @@
 import type { Enumeration as EnumerationType, EnumerationValue } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type EnumerationSchemaOptions<T extends EnumerationType> = SimpleSchemaOptions<EnumerationValue<T>>;
 export declare class EnumerationSchema<const T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
@@ -10,4 +10,4 @@ export declare class EnumerationSchema<const T extends EnumerationType> extends
     constructor(enumeration: T, options?: EnumerationSchemaOptions<T>);
 }
 export declare function enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T>): EnumerationSchema<T>;
-export declare function Enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/function.d.ts

@@ -1,9 +1,23 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { AbstractConstructor, Function } from '../../types.js';
+import { type CombinedSchemaDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import type { Schema, SchemaTestable } from '../schema.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type FunctionSchemaOptions = SimpleSchemaOptions<Function>;
-export declare class FunctionSchema extends SimpleSchema<Function> {
+export type FunctionSchemaOptions<T extends Function> = SimpleSchemaOptions<T> & {
+    parameterNames?: (string | null)[];
+};
+type MappedParameters<T> = {
+    [I in keyof T]: SchemaTestable<T[I]>;
+};
+export declare class FunctionSchema<T extends (...args: any[]) => any> extends SimpleSchema<T> {
     readonly name = "function";
-    constructor(options?: FunctionSchemaOptions);
+    readonly parameterSchemas: MappedParameters<Parameters<T>> | null;
+    readonly parameterNames: (string | null)[];
+    readonly returnValueSchema: SchemaTestable<ReturnType<T>> | null;
+    constructor(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T>);
 }
-export declare function func(options?: FunctionSchemaOptions): FunctionSchema;
-export declare function FunctionProperty(options?: FunctionSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function func<T extends (...args: any[]) => any>(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T>): FunctionSchema<T>;
+export declare function Method<T extends (...args: any[]) => any>(options?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator;
+export declare function Method<T extends (...args: any[]) => any>(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator;
+export declare function getFunctionSchemaFromReflection(type: AbstractConstructor, method: string | symbol): Schema<Function> | FunctionSchema<(...args: any[]) => any>;
+export declare function tryGetFunctionSchemaFromReflection(type: AbstractConstructor, method: string | symbol): Schema<Function> | FunctionSchema<(...args: any[]) => any> | null;
+export {};

package/schema/schemas/function.js

@@ -1,16 +1,67 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
-import { isFunction } from '../../utils/type-guards.js';
-import { PropertySchema } from '../decorators/index.js';
+import { reflectionRegistry } from '../../reflection/registry.js';
+import { createMethodDecorator } from '../../reflection/utils.js';
+import { isArray, isDefined, isFunction, isNull, isUndefined } from '../../utils/type-guards.js';
+import { createSchemaDecorator, Property } from '../decorators/index.js';
+import { schemaReflectionDataToSchema } from '../decorators/utils.js';
+import { schemaTestableToSchema } from '../testable.js';
+import { never } from './never.js';
+import { optional } from './optional.js';
 import { SimpleSchema } from './simple.js';
 export class FunctionSchema extends SimpleSchema {
     name = 'function';
-    constructor(options) {
+    parameterSchemas;
+    parameterNames;
+    returnValueSchema;
+    constructor(parameterSchemas, returnValueSchema, options) {
         super('function', isFunction, options);
+        this.parameterSchemas = parameterSchemas;
+        this.parameterNames = options?.parameterNames ?? [];
+        this.returnValueSchema = returnValueSchema;
     }
 }
-export function func(options) {
-    return new FunctionSchema(options);
+export function func(parameterSchemas, returnValueSchema, options) {
+    return new FunctionSchema(parameterSchemas, returnValueSchema, options);
 }
-export function FunctionProperty(options) {
-    return PropertySchema((data) => func({ description: data.description, example: data.example, ...options }), options);
+export function Method(parameterSchemasOrOptions, returnValueSchema, optionsOrNothing) {
+    if (isArray(parameterSchemasOrOptions) || isNull(parameterSchemasOrOptions)) {
+        return Property({
+            ...optionsOrNothing,
+            schema: (data) => func(parameterSchemasOrOptions, returnValueSchema, { description: data.description, example: data.example, ...optionsOrNothing })
+        });
+    }
+    return createMethodDecorator({
+        handler: (data, _metdata, originalArguments) => {
+            createSchemaDecorator(parameterSchemasOrOptions)(...originalArguments);
+            Property(getFunctionSchemaFromReflection(data.constructor, data.methodKey), parameterSchemasOrOptions);
+        }
+    });
+}
+export function getFunctionSchemaFromReflection(type, method) {
+    const schema = tryGetFunctionSchemaFromReflection(type, method);
+    if (isNull(schema)) {
+        throw new Error(`Could not get functions schema for ${type.name}["${String(method)}"] from reflection data.`);
+    }
+    return schema;
+}
+export function tryGetFunctionSchemaFromReflection(type, method) {
+    const typeMetadata = reflectionRegistry.getMetadata(type);
+    const methodMetadata = typeMetadata?.methods.get(method);
+    if (isUndefined(methodMetadata)) {
+        return null;
+    }
+    const methodData = methodMetadata.data.tryGet('schema') ?? {};
+    if (isFunction(methodData.schema)) {
+        return schemaTestableToSchema(methodData.schema(methodData));
+    }
+    const parameterSchemas = methodMetadata.parameters.map((parameterMetadata) => {
+        const parameterData = parameterMetadata.data.tryGet('schema') ?? {};
+        return schemaReflectionDataToSchema(parameterData, parameterMetadata.type, { type, key: `${String(method)}(parameter:${parameterMetadata.index})` });
+    });
+    const parameterNames = methodMetadata.parameters.map((parameterMetadata) => {
+        const parameterData = parameterMetadata.data.tryGet('schema') ?? {};
+        return parameterData.parameter?.name ?? null;
+    });
+    const returnTypeSchema = isDefined(methodData.method?.returnType) ? methodData.method.returnType(methodData) : (methodMetadata.returnType ?? optional(never()));
+    return func(parameterSchemas, returnTypeSchema, { parameterNames, description: methodData.description, example: methodData.example });
 }

package/schema/schemas/instance.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { AbstractConstructor } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type InstanceSchemaOptions<T extends AbstractConstructor> = SchemaOptions<InstanceType<T>>;
 export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
@@ -10,4 +10,4 @@ export declare class InstanceSchema<T extends AbstractConstructor> extends Schem
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>>;
 }
 export declare function instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T>): InstanceSchema<T>;
-export declare function Instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/literal.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type LiteralSchemaOptions<T> = SchemaOptions<T>;
 export declare class LiteralSchema<const T> extends Schema<T> {
@@ -9,4 +9,4 @@ export declare class LiteralSchema<const T> extends Schema<T> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
 }
 export declare function literal<const T>(value: T, options?: LiteralSchemaOptions<T>): LiteralSchema<T>;
-export declare function Literal<const T>(value: T, options?: LiteralSchemaOptions<T> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Literal<const T>(value: T, options?: LiteralSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/never.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { Schema, SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type NeverSchemaOptions = SchemaOptions<never>;
 export declare class NeverSchema extends Schema<never> {
     readonly name = "never";

package/schema/schemas/nullable.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { TypedOmit } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } 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;
@@ -9,4 +9,4 @@ export declare class NullableSchema<T> extends Schema<T | null> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;
 }
 export declare function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T>;
-export declare function Nullable<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'nullable'>): SchemaPropertyDecorator;
+export declare function Nullable<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'nullable'>): SchemaPropertyDecorator;

package/schema/schemas/nullable.js

@@ -1,6 +1,6 @@
 import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isNull } from '../../utils/type-guards.js';
-import { createSchemaPropertyDecorator } from '../decorators/index.js';
+import { createSchemaDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class NullableSchema extends Schema {
@@ -25,5 +25,5 @@ export function nullable(schema) {
     return new NullableSchema(schema);
 }
 export function Nullable(schema, options) {
-    return createSchemaPropertyDecorator({ schema: () => schema, ...options, nullable: true });
+    return createSchemaDecorator({ schema: () => schema, ...options, nullable: true });
 }

package/schema/schemas/number.d.ts

@@ -1,5 +1,5 @@
-import { TypedOmit } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { TypedOmit } from '../../types.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type NumberSchemaOptions = SimpleSchemaOptions<number> & {
     integer?: boolean;
@@ -15,5 +15,5 @@ export declare class NumberSchema extends SimpleSchema<number> {
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;
 export declare function integer(options?: TypedOmit<NumberSchemaOptions, 'integer'>): NumberSchema;
-export declare function NumberProperty(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
-export declare function Integer(options?: SchemaPropertyDecoratorOptions & TypedOmit<NumberSchemaOptions, 'integer'>): SchemaPropertyDecorator;
+export declare function NumberProperty(options?: SchemaDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+export declare function Integer(options?: SchemaDecoratorOptions & TypedOmit<NumberSchemaOptions, 'integer'>): SchemaPropertyDecorator;

package/schema/schemas/object.d.ts

@@ -2,7 +2,7 @@ import type { EmptyObject, Merge } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import { type Decorator } from '../../reflection/index.js';
 import type { AbstractConstructor, OneOrMany, PartialProperty, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../types.js';
-import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions } from '../decorators/index.js';
 import { type OPTIONAL, Schema, type SchemaOptions, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type Record<K extends PropertyKey = PropertyKey, V = any> = RecordType<K, V>;
 export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
@@ -86,6 +86,6 @@ export declare function omit<const T extends Record, const K extends keyof T>(sc
 export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
 declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | ObjectSchema<T> | null;
 export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
-export declare function Record<K extends PropertyKey, V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaPropertyDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
+export declare function Record<K extends PropertyKey, V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
 export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
 export {};

package/schema/schemas/object.js

@@ -7,10 +7,10 @@ import { filterObject, fromEntries, mapObjectValues, objectKeys } from '../../ut
 import { assert, isArray, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Class, PropertySchema } from '../decorators/index.js';
+import { schemaReflectionDataToSchema } from '../decorators/utils.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
-import { array } from './array.js';
-import { nullable } from './nullable.js';
+import { getFunctionSchemaFromReflection } from './function.js';
 import { optional } from './optional.js';
 export const tryGetSchemaFromReflection = memoizeSingle(_tryGetSchemaFromReflection, { weak: true });
 export class ObjectSchema extends Schema {
@@ -168,22 +168,11 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     const properties = {};
     for (const [key, propertyMetadata] of metadata.properties) {
         const reflectionData = propertyMetadata.data.tryGet('schema');
-        if (isUndefined(reflectionData?.schema) && (propertyMetadata.type == Object)) {
-            throw new Error(`Schema of property "${String(key)}" on type ${type.name} is inferred as Object. This is most likely unwanted and happens if the property is defined as partial or the type is an union. Use an explicit @Property(Object) if this is wanted.`);
-        }
-        let propertySchema = isDefined(reflectionData?.schema) ? reflectionData.schema(reflectionData) : propertyMetadata.type;
-        if (isUndefined(propertySchema)) {
-            throw new Error(`Could not infer schema for property "${String(key)}" on type ${type.name}. This happens if neither explicit @Property(type) is used nor reflection metadata is available.`);
-        }
-        if (reflectionData?.array == true) {
-            propertySchema = array(propertySchema);
-        }
-        if (reflectionData?.nullable == true) {
-            propertySchema = nullable(propertySchema);
-        }
-        if (reflectionData?.optional == true) {
-            propertySchema = optional(propertySchema);
-        }
+        const propertySchema = schemaReflectionDataToSchema(reflectionData, type, { type, key });
+        properties[key] = propertySchema;
+    }
+    for (const [key] of metadata.methods) {
+        const propertySchema = getFunctionSchemaFromReflection(type, key);
         properties[key] = propertySchema;
     }
     return properties;

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

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { OneOrMany as OneOrManyType } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type OneOrManySchemaOptions<T> = SchemaOptions<T | T[]>;
 export type OneOrMany<T> = OneOrManyType<T>;
@@ -11,4 +11,4 @@ export declare class OneOrManySchema<T> extends Schema<T | T[]> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | T[]>;
 }
 export declare function oneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T>): OneOrManySchema<T>;
-export declare function OneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function OneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/optional.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { TypedOmit } from '../../types.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } 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;
@@ -10,4 +10,4 @@ export declare class OptionalSchema<T> extends Schema<T | undefined> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | undefined>;
 }
 export declare function optional<T>(schema: SchemaTestable<T>): OptionalSchema<T>;
-export declare function Optional<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'optional'>): SchemaPropertyDecorator;
+export declare function Optional<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'optional'>): SchemaPropertyDecorator;

package/schema/schemas/optional.js

@@ -1,6 +1,6 @@
 import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { isUndefined } from '../../utils/type-guards.js';
-import { createSchemaPropertyDecorator } from '../decorators/index.js';
+import { createSchemaDecorator } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class OptionalSchema extends Schema {
@@ -25,5 +25,5 @@ export function optional(schema) {
     return new OptionalSchema(schema);
 }
 export function Optional(schema, options) {
-    return createSchemaPropertyDecorator({ schema: () => schema, ...options, optional: true });
+    return createSchemaDecorator({ schema: () => schema, ...options, optional: true });
 }

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

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type ReadableStreamSchemaOptions = SimpleSchemaOptions<ReadableStream>;
 export declare class ReadableStreamSchema extends SimpleSchema<ReadableStream> {
@@ -6,4 +6,4 @@ export declare class ReadableStreamSchema extends SimpleSchema<ReadableStream> {
     constructor(options?: ReadableStreamSchemaOptions);
 }
 export declare function readableStream(options?: ReadableStreamSchemaOptions): ReadableStreamSchema;
-export declare function ReadableStreamProperty(options?: SchemaPropertyDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;
+export declare function ReadableStreamProperty(options?: SchemaDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/regexp.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type RegExpSchemaOptions = SimpleSchemaOptions<RegExp>;
 export declare class RegExpSchema extends SimpleSchema<RegExp> {
@@ -6,4 +6,4 @@ export declare class RegExpSchema extends SimpleSchema<RegExp> {
     constructor(options?: RegExpSchemaOptions);
 }
 export declare function regExp(options?: RegExpSchemaOptions): RegExpSchema;
-export declare function RegExpProperty(options?: SchemaPropertyDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;
+export declare function RegExpProperty(options?: SchemaDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/string.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type StringSchemaOptions = SimpleSchemaOptions<string> & {
     pattern?: RegExp | string;
@@ -11,4 +11,4 @@ export declare class StringSchema extends SimpleSchema<string> {
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;
-export declare function StringProperty(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;
+export declare function StringProperty(options?: SchemaDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/symbol.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type SymbolSchemaOptions = SimpleSchemaOptions<symbol>;
 export declare class SymbolSchema extends SimpleSchema<symbol> {
@@ -6,4 +6,4 @@ export declare class SymbolSchema extends SimpleSchema<symbol> {
     constructor(options?: SymbolSchemaOptions);
 }
 export declare function symbol(options?: SymbolSchemaOptions): SymbolSchema;
-export declare function SymbolProperty(options?: SymbolSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function SymbolProperty(options?: SymbolSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

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

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type Uint8ArraySchemaOptions = SimpleSchemaOptions<Uint8Array> & {
     /** Minimum byte length */
@@ -13,4 +13,4 @@ export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     constructor(options?: Uint8ArraySchemaOptions);
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
-export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/union.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 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>> {
@@ -11,5 +11,5 @@ export declare class UnionSchema<T extends [SchemaTestable, ...SchemaTestable[]]
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<UnionSchemaType<T>>;
 }
 export declare function union<T extends [SchemaTestable, ...SchemaTestable[]]>(...schemas: T): UnionSchema<T>;
-export declare function Union(...schemasAndOptions: [SchemaTestable, ...SchemaTestable[]] | [SchemaTestable, ...SchemaTestable[], options: SchemaPropertyDecoratorOptions]): SchemaPropertyDecorator;
+export declare function Union(...schemasAndOptions: [SchemaTestable, ...SchemaTestable[]] | [SchemaTestable, ...SchemaTestable[], options: SchemaDecoratorOptions]): SchemaPropertyDecorator;
 export {};

package/schema/schemas/unknown.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestResult } from '../schema.js';
 export type UnknownSchemaOptions = SchemaOptions<unknown>;
 export declare class UnknownSchema extends Schema<unknown> {
@@ -6,4 +6,4 @@ export declare class UnknownSchema extends Schema<unknown> {
     _test(value: unknown): SchemaTestResult<unknown>;
 }
 export declare function unknown(options?: UnknownSchemaOptions): UnknownSchema;
-export declare function Unknown(options?: UnknownSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Unknown(options?: UnknownSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/testable.d.ts

@@ -1,3 +1,3 @@
-import { Schema, type SchemaTestable } from './schema.js';
-export declare function schemaTestableToSchema<T>(testable: SchemaTestable<T>): Schema<T>;
+import { Schema, type SchemaOptions, type SchemaTestable } from './schema.js';
+export declare function schemaTestableToSchema<T>(testable: SchemaTestable<T>, options?: SchemaOptions<T>): Schema<T>;
 export declare function isSchemaTestable(value: any): value is SchemaTestable;

package/schema/testable.js

@@ -9,27 +9,27 @@ 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) {
+export function schemaTestableToSchema(testable, options) {
     if (testable instanceof Schema) {
         return testable;
     }
     switch (testable) {
         case String:
-            return string();
+            return string(options);
         case Number:
-            return number();
+            return number(options);
         case Boolean:
-            return boolean();
+            return boolean(options);
         case BigInt:
-            return bigint();
+            return bigint(options);
         case Symbol:
-            return symbol();
+            return symbol(options);
         case Function:
-            return func();
+            return func(null, null);
         case Uint8Array:
-            return uint8Array();
+            return uint8Array(options);
         case ReadableStream:
-            return readableStream();
+            return readableStream(options);
         default:
             return getSchemaFromReflection(testable);
     }