@tstdl/base 0.91.31 → 0.91.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.31",
+  "version": "0.91.33",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/password/password-check-result.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/decorators/property.js';
+import { NumberProperty } from '../schema/index.js';
 import { Array } from '../schema/schemas/array.js';
 import { Enumeration } from '../schema/schemas/enumeration.js';
 export var PasswordStrength;
@@ -33,7 +33,7 @@ __decorate([
     __metadata("design:type", Number)
 ], PasswordCheckResult.prototype, "strength", void 0);
 __decorate([
-    Property({ optional: true }),
+    NumberProperty({ optional: true }),
     __metadata("design:type", Number)
 ], PasswordCheckResult.prototype, "pwned", void 0);
 __decorate([

package/schema/decorators/property.d.ts

@@ -1,7 +1,10 @@
+import type { SetRequired } from 'type-fest';
 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 SchemaPropertyDecoratorOptionsWithRequiredSchema = SetRequired<SchemaPropertyReflectionData, 'schema'>;
+export type SchemaPropertyDecoratorOptionsWithoutSchema = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
+export declare function Property(schema: SchemaTestable, options?: SchemaPropertyDecoratorOptionsWithoutSchema): Decorator<'property' | 'accessor'>;
+export declare function Property(options: SchemaPropertyDecoratorOptionsWithRequiredSchema): Decorator<'property' | 'accessor'>;

package/schema/decorators/property.js

@@ -4,7 +4,7 @@ import { isSchemaTestable } from '../testable.js';
 import { createSchemaPropertyDecorator } from './utils.js';
 export function Property(schemaOrOptions, optionsOrNothing) {
     if (isDefined(optionsOrNothing)) {
-        return createSchemaPropertyDecorator({ schema: schemaOrOptions, ...optionsOrNothing });
+        return createSchemaPropertyDecorator({ ...optionsOrNothing, schema: schemaOrOptions });
     }
     if (isSchemaTestable(schemaOrOptions)) {
         return createSchemaPropertyDecorator({ schema: schemaOrOptions });

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 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);
         }