@tstdl/base 0.91.30 → 0.91.32

package/authentication/models/authentication-credentials.model.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Property } from '../../schema/index.js';
+import { NumberProperty, StringProperty, Uint8ArrayProperty } from '../../schema/index.js';
 export class AuthenticationCredentials {
     id;
     subject;
@@ -16,23 +16,23 @@ export class AuthenticationCredentials {
     hash;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], AuthenticationCredentials.prototype, "id", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], AuthenticationCredentials.prototype, "subject", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], AuthenticationCredentials.prototype, "hashVersion", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], AuthenticationCredentials.prototype, "salt", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], AuthenticationCredentials.prototype, "hash", void 0);
 export class NewAuthenticationCredentials {
@@ -42,18 +42,18 @@ export class NewAuthenticationCredentials {
     hash;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], NewAuthenticationCredentials.prototype, "subject", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], NewAuthenticationCredentials.prototype, "hashVersion", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], NewAuthenticationCredentials.prototype, "salt", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], NewAuthenticationCredentials.prototype, "hash", void 0);

package/authentication/models/authentication-session.model.d.ts

@@ -1,9 +1,9 @@
 export declare class AuthenticationSession {
     id: string;
     subject: string;
-    /** timestamp */
+    /** Timestamp */
     begin: number;
-    /** timestamp */
+    /** Timestamp */
     end: number;
     refreshTokenHashVersion: number;
     refreshTokenSalt: Uint8Array;

package/authentication/models/authentication-session.model.js

@@ -7,44 +7,44 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Property } from '../../schema/index.js';
+import { NumberProperty, StringProperty, Uint8ArrayProperty } from '../../schema/index.js';
 export class AuthenticationSession {
     id;
     subject;
-    /** timestamp */
+    /** Timestamp */
     begin;
-    /** timestamp */
+    /** Timestamp */
     end;
     refreshTokenHashVersion;
     refreshTokenSalt;
     refreshTokenHash;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], AuthenticationSession.prototype, "id", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], AuthenticationSession.prototype, "subject", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], AuthenticationSession.prototype, "begin", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], AuthenticationSession.prototype, "end", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], AuthenticationSession.prototype, "refreshTokenHashVersion", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], AuthenticationSession.prototype, "refreshTokenSalt", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], AuthenticationSession.prototype, "refreshTokenHash", void 0);
 export class NewAuthenticationSession {
@@ -56,26 +56,26 @@ export class NewAuthenticationSession {
     refreshTokenHash;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], NewAuthenticationSession.prototype, "subject", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], NewAuthenticationSession.prototype, "begin", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], NewAuthenticationSession.prototype, "end", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], NewAuthenticationSession.prototype, "refreshTokenHashVersion", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], NewAuthenticationSession.prototype, "refreshTokenSalt", void 0);
 __decorate([
-    Property(),
+    Uint8ArrayProperty(),
     __metadata("design:type", Uint8Array)
 ], NewAuthenticationSession.prototype, "refreshTokenHash", void 0);

package/authentication/models/init-secret-reset-data.model.js

@@ -7,17 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Property } from '../../schema/decorators/property.js';
+import { StringProperty } from '../../schema/index.js';
 export class InitSecretResetData {
     /** Subject is not checked for existence. */
     subject;
     token;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], InitSecretResetData.prototype, "subject", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], InitSecretResetData.prototype, "token", void 0);

package/authentication/models/token-payload-base.model.d.ts

@@ -1,11 +1,11 @@
 export declare class TokenPayloadBase {
-    /** token id */
+    /** Token id */
     jti: string;
-    /** issue timestamp in seconds */
+    /** Issue timestamp in seconds */
     iat: number;
-    /** expiration timestamp in seconds */
+    /** Expiration timestamp in seconds */
     exp: number;
-    /** refresh token expiration timestamp in seconds */
+    /** Refresh token expiration timestamp in seconds */
     refreshTokenExp: number;
     sessionId: string;
     subject: string;

package/authentication/models/token-payload-base.model.js

@@ -7,45 +7,45 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Property } from '../../schema/decorators/property.js';
+import { NumberProperty, StringProperty } from '../../schema/index.js';
 export class TokenPayloadBase {
-    /** token id */
+    /** Token id */
     jti;
-    /** issue timestamp in seconds */
+    /** Issue timestamp in seconds */
     iat;
-    /** expiration timestamp in seconds */
+    /** Expiration timestamp in seconds */
     exp;
-    /** refresh token expiration timestamp in seconds */
+    /** Refresh token expiration timestamp in seconds */
     refreshTokenExp;
     sessionId;
     subject;
     impersonator;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TokenPayloadBase.prototype, "jti", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], TokenPayloadBase.prototype, "iat", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], TokenPayloadBase.prototype, "exp", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], TokenPayloadBase.prototype, "refreshTokenExp", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TokenPayloadBase.prototype, "sessionId", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TokenPayloadBase.prototype, "subject", void 0);
 __decorate([
-    Property({ optional: true }),
+    StringProperty({ optional: true }),
     __metadata("design:type", String)
 ], TokenPayloadBase.prototype, "impersonator", void 0);

package/examples/api/basic-overview.js

@@ -18,7 +18,7 @@ import { configureHttpClient } from '../../http/client/module.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { inject } from '../../injector/inject.js';
 import { WebServerModule } from '../../module/modules/web-server.module.js';
-import { NumberProperty, Property, array, boolean, number, object } from '../../schema/index.js';
+import { NumberProperty, StringProperty, array, boolean, number, object } from '../../schema/index.js';
 import { timeout } from '../../utils/timing.js';
 import { Agent } from 'undici';
 class User {
@@ -30,7 +30,7 @@ __decorate([
     __metadata("design:type", Number)
 ], User.prototype, "id", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], User.prototype, "name", void 0);
 const users = [

package/examples/api/custom-authentication.js

@@ -26,7 +26,7 @@ import { Singleton } from '../../injector/decorators.js';
 import { inject, injectAsync } from '../../injector/inject.js';
 import { configureLocalMessageBus } from '../../message-bus/local/module.js';
 import { WebServerModule } from '../../module/modules/index.js';
-import { Property, emptyObjectSchema } from '../../schema/index.js';
+import { StringProperty, emptyObjectSchema } from '../../schema/index.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
 import { first } from '../../utils/iterable-helpers/first.js';
 import { skip } from '../../utils/iterable-helpers/skip.js';
@@ -57,14 +57,14 @@ class CustomTokenPaylod {
     deviceRegistrationId;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], CustomTokenPaylod.prototype, "deviceRegistrationId", void 0);
 class AuthenticationData {
     deviceId;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], AuthenticationData.prototype, "deviceId", void 0);
 const CustomAuthenticationApiClient = getAuthenticationApiClient(CustomTokenPaylod, AuthenticationData, emptyObjectSchema);

package/examples/orm/user.model.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Entity, Integer, Unique } from '../../orm/index.js';
-import { Array, Property } from '../../schema/index.js';
+import { Array, BooleanProperty, StringProperty } from '../../schema/index.js';
 export class User extends Entity {
     static entityName = 'User';
     name;
@@ -18,7 +18,7 @@ export class User extends Entity {
     mail;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], User.prototype, "name", void 0);
 __decorate([
@@ -30,7 +30,7 @@ __decorate([
     __metadata("design:type", Object)
 ], User.prototype, "age", void 0);
 __decorate([
-    Property(),
+    BooleanProperty(),
     __metadata("design:type", Boolean)
 ], User.prototype, "hasAge", void 0);
 __decorate([

package/mail/mail.client.js

@@ -7,19 +7,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Property } from '../schema/decorators/property.js';
-import { BooleanProperty } from '../schema/index.js';
+import { BooleanProperty, NumberProperty, StringProperty } from '../schema/index.js';
 import { Optional } from '../schema/schemas/optional.js';
 export class MailClientAuthConfig {
     user;
     password;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], MailClientAuthConfig.prototype, "user", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], MailClientAuthConfig.prototype, "password", void 0);
 export class MailClientConfig {
@@ -30,11 +29,11 @@ export class MailClientConfig {
     auth;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], MailClientConfig.prototype, "host", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], MailClientConfig.prototype, "port", void 0);
 __decorate([

package/orm/entity.js

@@ -18,15 +18,15 @@ export class EntityMetadata {
     attributes;
 }
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revision", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revisionTimestamp", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "createTimestamp", void 0);
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.30",
+  "version": "0.91.32",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,7 +152,7 @@
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.9",
+    "mongodb": "^6.10",
     "nodemailer": "^6.9",
     "pg": "8.13",
     "playwright": "^1.48",

package/schema/decorators/property.d.ts

@@ -2,6 +2,7 @@ import type { Decorator } from '../../reflection/index.js';
 import type { TypedOmit } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
 import type { SchemaPropertyReflectionData } from './types.js';
-export type SchemaPropertyDecoratorOptions = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
-export declare function Property(schema?: SchemaTestable, options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
-export declare function Property(options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
+export type SchemaPropertyDecoratorOptions = SchemaPropertyReflectionData;
+export type SchemaPropertyDecoratorOptionsWithoutSchema = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
+export declare function Property(schema: SchemaTestable, options?: SchemaPropertyDecoratorOptionsWithoutSchema): Decorator<'property' | 'accessor'>;
+export declare function Property(options: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;

package/schema/schemas/array.d.ts

@@ -2,11 +2,14 @@ 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 { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { Coercible } from '../types.js';
+export type ArraySchemaOptions = Coercible;
 export declare class ArraySchema<T> extends Schema<T[]> {
+    #private;
     readonly name: string;
     readonly itemSchema: Schema<T>;
-    constructor(itemSchema: SchemaTestable<T>);
+    constructor(itemSchema: SchemaTestable<T>, options?: ArraySchemaOptions);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
 }
-export declare function array<T>(schema: SchemaTestable<T>): ArraySchema<T>;
-export declare function Array(schema: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;
+export declare function array<T>(schema: SchemaTestable<T>, options?: ArraySchemaOptions): ArraySchema<T>;
+export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions & TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -5,15 +5,20 @@ import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class ArraySchema extends Schema {
+    #options;
     name;
     itemSchema;
-    constructor(itemSchema) {
+    constructor(itemSchema, options = {}) {
         super();
+        this.#options = options;
         this.itemSchema = schemaTestableToSchema(itemSchema);
         this.name = `Array[${this.itemSchema.name}]`;
     }
     _test(value, path, options) {
         if (!isArray(value)) {
+            if ((this.#options.coerce ?? options.coerce) == true) {
+                return this._test([value], path, options);
+            }
             return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
         }
         const values = [];
@@ -27,9 +32,9 @@ export class ArraySchema extends Schema {
         return { valid: true, value: values };
     }
 }
-export function array(schema) {
-    return new ArraySchema(schema);
+export function array(schema, options) {
+    return new ArraySchema(schema, options);
 }
 export function Array(schema, options) {
-    return Property(schema, { ...options, array: true });
+    return Property(array(schema, options), options);
 }

package/schema/schemas/deferred.d.ts

@@ -0,0 +1,12 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } 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;
+    readonly testable: T;
+    readonly schema: Schema<SchemaOutput<T>>;
+    constructor(schema: () => T);
+    _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<T extends SchemaTestable>(schema: () => T, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/deferred.js

@@ -0,0 +1,23 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class DeferredSchema extends Schema {
+    name;
+    testable;
+    schema;
+    constructor(schema) {
+        super();
+        lazyProperty(this, 'schema', () => schemaTestableToSchema(schema()));
+        lazyProperty(this, 'name', () => `Deferred[${this.schema.name}]`);
+    }
+    _test(value, path, options) {
+        return this.schema._test(value, path, options);
+    }
+}
+export function deferred(schema) {
+    return new DeferredSchema(schema);
+}
+export function Deferred(schema, options) {
+    return Property(deferred(schema), options);
+}

package/schema/schemas/index.d.ts

@@ -4,6 +4,7 @@ export * from './bigint.js';
 export * from './boolean.js';
 export * from './date.js';
 export * from './defaulted.js';
+export * from './deferred.js';
 export * from './enumeration.js';
 export * from './function.js';
 export * from './instance.js';

package/schema/schemas/index.js

@@ -4,6 +4,7 @@ export * from './bigint.js';
 export * from './boolean.js';
 export * from './date.js';
 export * from './defaulted.js';
+export * from './deferred.js';
 export * from './enumeration.js';
 export * from './function.js';
 export * from './instance.js';

package/schema/schemas/number.d.ts

@@ -2,10 +2,14 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type NumberSchemaOptions = SimpleSchemaOptions & {
     integer?: boolean;
+    minimum?: number;
+    maximum?: number;
 };
 export declare class NumberSchema extends SimpleSchema<number> {
     readonly name = "number";
     readonly integer: boolean;
+    readonly minimum: number | null;
+    readonly maximum: number | null;
     constructor(options?: NumberSchemaOptions);
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;

package/schema/schemas/number.js

@@ -5,6 +5,8 @@ import { SimpleSchema } from './simple.js';
 export class NumberSchema extends SimpleSchema {
     name = 'number';
     integer;
+    minimum;
+    maximum;
     constructor(options) {
         super('number', isNumber, options, {
             coercers: {
@@ -18,10 +20,13 @@ export class NumberSchema extends SimpleSchema {
                 bigint: (value) => ({ success: true, value: globalThis.Number(value), valid: false })
             },
             constraints: [
-                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
+                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'Value is not an integer.' }) : null,
+                isNumber(options?.minimum) ? (value) => (value >= this.minimum) ? ({ success: true }) : ({ success: false, error: `Value must be more than or equal to ${this.minimum}.` }) : null,
+                isNumber(options?.maximum) ? (value) => (value >= this.maximum) ? ({ success: true }) : ({ success: false, error: `Value must be less than or equal to ${this.maximum}.` }) : null
             ]
         });
         this.integer = options?.integer ?? false;
+        this.minimum = options?.minimum ?? null;
     }
 }
 export function number(options) {

package/schema/schemas/object.js

@@ -159,9 +159,12 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     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 when the property is defined as partial or the type is an union. Use an explicit @Property(Object) if this is wanted.`);
+            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 = reflectionData?.schema ?? propertyMetadata.type;
+        if (isUndefined(propertySchema)) {
+            throw new Error(`Could not infer schema for "${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);
         }

package/schema/schemas/string.d.ts

@@ -2,9 +2,12 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type StringSchemaOptions = SimpleSchemaOptions & {
     pattern?: RegExp | string;
+    lowercase?: boolean;
 };
 export declare class StringSchema extends SimpleSchema<string> {
     readonly name: string;
+    readonly pattern: RegExp | null;
+    readonly lowercase: boolean;
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;

package/schema/schemas/string.js

@@ -3,8 +3,9 @@ import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class StringSchema extends SimpleSchema {
     name = 'string';
+    pattern;
+    lowercase;
     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, {
             coercers: {
                 number: (value) => ({ success: true, value: globalThis.String(value), valid: true }),
@@ -12,9 +13,14 @@ export class StringSchema extends SimpleSchema {
                 bigint: (value) => ({ success: true, value: globalThis.String(value), valid: true })
             },
             constraints: [
-                isDefined(pattern) ? ((value) => pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })) : null
+                isDefined(options?.pattern) ? ((value) => this.pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })) : null
             ]
         });
+        this.pattern = isString(options?.pattern)
+            ? RegExp(options.pattern, 'u')
+            : isRegExp(options?.pattern)
+                ? options.pattern
+                : null;
     }
 }
 export function string(options) {

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

@@ -8,8 +8,9 @@ export type Uint8ArraySchemaOptions = SimpleSchemaOptions & {
 };
 export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     readonly name = "Uint8Array";
-    readonly options: Uint8ArraySchemaOptions;
+    readonly minimumLength: number | null;
+    readonly maximumLength: number | null;
     constructor(options?: Uint8ArraySchemaOptions);
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
-export declare function Uint8ArrayProperty(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/uint8-array.js

@@ -3,19 +3,22 @@ import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class Uint8ArraySchema extends SimpleSchema {
     name = 'Uint8Array';
-    options;
+    minimumLength;
+    maximumLength;
     constructor(options) {
         super('Uint8Array', isUint8Array, options, {
             constraints: [
-                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${options.minimumLength} bytes.` }) : null,
-                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${options.maximumLength} bytes.` }) : null
+                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= this.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${this.minimumLength} bytes.` }) : null,
+                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= this.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${this.maximumLength} bytes.` }) : null
             ]
         });
+        this.minimumLength = options?.minimumLength ?? null;
+        this.maximumLength = options?.maximumLength ?? null;
     }
 }
 export function uint8Array(options) {
     return new Uint8ArraySchema(options);
 }
-export function Uint8ArrayProperty(schemaOptions, options) {
-    return Property(uint8Array(schemaOptions), options);
+export function Uint8ArrayProperty(options) {
+    return Property(uint8Array(options), options);
 }

package/templates/resolvers/file.template-resolver.d.ts

@@ -1,5 +1,4 @@
-import type { Resolvable } from '../../injector/interfaces.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
+import { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
 import type { TypedOmit } from '../../types.js';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';

package/templates/resolvers/file.template-resolver.js

@@ -14,7 +14,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { InjectArg, Singleton } from '../../injector/decorators.js';
-import { Property } from '../../schema/index.js';
+import { StringProperty } from '../../schema/index.js';
 import { TemplateField } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';
 export const fileTemplateProviderConfig = {};
@@ -22,7 +22,7 @@ export class FileTemplateField extends TemplateField {
     templateFile;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], FileTemplateField.prototype, "templateFile", void 0);
 let FileTemplateResolver = class FileTemplateResolver extends TemplateResolver {

package/templates/resolvers/jsx.template-resolver.d.ts

@@ -1,7 +1,6 @@
 import type { PartialProperty, Record, TypedOmit } from '../../types.js';
 import type { ComponentClass, FunctionComponent } from 'preact';
-import type { Template } from '../template.model.js';
-import { TemplateField } from '../template.model.js';
+import { Template, TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';
 export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
@@ -9,7 +8,6 @@ export declare class JsxTemplateField<Renderer extends string = string, Options
     template: JsxTemplate<Context>;
 }
 export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
-    constructor();
     canHandle(resolver: string): boolean;
     resolve(field: JsxTemplateField): JsxTemplate;
 }

package/templates/resolvers/jsx.template-resolver.js

@@ -8,20 +8,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Singleton } from '../../injector/decorators.js';
-import { Property } from '../../schema/index.js';
+import { FunctionProperty } from '../../schema/index.js';
 import { TemplateField, simpleTemplate } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';
 export class JsxTemplateField extends TemplateField {
     template;
 }
 __decorate([
-    Property(),
+    FunctionProperty(),
     __metadata("design:type", Object)
 ], JsxTemplateField.prototype, "template", void 0);
 let JsxTemplateResolver = class JsxTemplateResolver extends TemplateResolver {
-    constructor() {
-        super();
-    }
     canHandle(resolver) {
         return (resolver == 'jsx');
     }
@@ -30,8 +27,7 @@ let JsxTemplateResolver = class JsxTemplateResolver extends TemplateResolver {
     }
 };
 JsxTemplateResolver = __decorate([
-    Singleton(),
-    __metadata("design:paramtypes", [])
+    Singleton()
 ], JsxTemplateResolver);
 export { JsxTemplateResolver };
 export function jsxTemplateField(field) {

package/templates/template.model.d.ts

@@ -14,7 +14,7 @@ export type TemplateFields<Fields extends Record<string, boolean>, Resolver exte
 }>;
 export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
     readonly [templateContext]?: (context: Context) => void;
-    /** name of template */
+    /** Name of template */
     name: string;
     fields: TemplateFields<Fields, string, string, any, Context>;
     options?: TemplateOptions;

package/templates/template.model.js

@@ -7,18 +7,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Any, any, Class, object, Optional, Property } from '../schema/index.js';
+import { Any, any, Class, object, Optional, Property, StringProperty } from '../schema/index.js';
 let TemplateField = class TemplateField {
     resolver;
     renderer;
     options;
 };
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TemplateField.prototype, "resolver", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TemplateField.prototype, "renderer", void 0);
 __decorate([
@@ -31,13 +31,13 @@ TemplateField = __decorate([
 ], TemplateField);
 export { TemplateField };
 export class Template {
-    /** name of template */
+    /** Name of template */
     name;
     fields;
     options;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], Template.prototype, "name", void 0);
 __decorate([