@tstdl/base 0.91.0-beta1 → 0.91.0-beta3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.0-beta1",
+  "version": "0.91.0-beta3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -142,7 +142,7 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.4",
-    "drizzle-orm": "^0.31",
+    "drizzle-orm": "^0.32",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",

package/schema/decorators/utils.js

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { createPropertyOrAccessorDecorator } from '../../reflection/index.js';
-export function createSchemaPropertyDecorator(data) {
+import { filterUndefinedObjectProperties } from '../../utils/object/object.js';
+export function createSchemaPropertyDecorator(data = {}) {
     return createPropertyOrAccessorDecorator({
-        data: { schema: data },
+        data: { schema: filterUndefinedObjectProperties(data) },
         mergeData: true
     });
 }

package/schema/schemas/array.d.ts

@@ -1,5 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator } from '../decorators/index.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';
 export declare class ArraySchema<T> extends Schema<T[]> {
     readonly itemSchema: Schema<T>;
@@ -7,4 +8,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>): ArraySchema<T>;
-export declare function Array(schema: SchemaTestable): SchemaPropertyDecorator;
+export declare function Array(schema: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -26,6 +26,6 @@ export class ArraySchema extends Schema {
 export function array(schema) {
     return new ArraySchema(schema);
 }
-export function Array(schema) {
-    return Property(schema, { array: true });
+export function Array(schema, options) {
+    return Property(schema, { ...options, array: true });
 }

package/schema/schemas/bigint.d.ts

@@ -1,8 +1,9 @@
 import type { JsonPath } from '../../json-path/json-path.js';
+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> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<bigint>;
 }
 export declare function bigint(): BigIntSchema;
-export declare function BigInt(): SchemaPropertyDecorator;
+export declare function BigInt(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/bigint.js

@@ -14,6 +14,6 @@ export class BigIntSchema extends Schema {
 export function bigint() {
     return new BigIntSchema();
 }
-export function BigInt() {
-    return Property(bigint());
+export function BigInt(options) {
+    return Property(bigint(), options);
 }

package/schema/schemas/boolean.d.ts

@@ -7,9 +7,9 @@ export declare class BooleanSchema extends SimpleSchema<boolean> {
     constructor(options?: BooleanSchemaOptions);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<boolean>;
 }
-export declare function boolean(): BooleanSchema;
-export declare function Boolean(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function boolean(options?: BooleanSchemaOptions): BooleanSchema;
+export declare function Boolean(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
 /**
  * @deprecated use {@link Boolean()} instead
  */
-export declare function BooleanProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.js

@@ -36,11 +36,11 @@ export class BooleanSchema extends SimpleSchema {
         return { valid: false, error: SchemaError.expectedButGot('boolean', typeOf(value), path, { fast: options.fastErrors }) };
     }
 }
-export function boolean() {
-    return new BooleanSchema();
+export function boolean(options) {
+    return new BooleanSchema(options);
 }
 export function Boolean(options) {
-    return Property(boolean(), options);
+    return Property(boolean(options), options);
 }
 /**
  * @deprecated use {@link Boolean()} instead

package/schema/schemas/nullable.d.ts

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

package/schema/schemas/nullable.js

@@ -21,6 +21,6 @@ export class NullableSchema extends Schema {
 export function nullable(schema) {
     return new NullableSchema(schema);
 }
-export function Nullable() {
-    return createSchemaPropertyDecorator({ nullable: true });
+export function Nullable(schema, options) {
+    return createSchemaPropertyDecorator({ schema, ...options, nullable: true });
 }

package/schema/schemas/object.d.ts

@@ -1,6 +1,8 @@
 import type { EmptyObject, Merge } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { AbstractConstructor, OneOrMany, PartialProperty, Record, SimplifyObject, Type, TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { SchemaPropertyDecorator } from '../decorators/types.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
 export type ObjectSchemaFactory<T> = {
@@ -65,11 +67,13 @@ export declare function assign<T1 extends Record, T2 extends Record, T3 extends
 export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
 export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
 export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record, T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
-export declare function partial<T extends Record>(schema: ObjectSchema<T>): ObjectSchema<Partial<T>>;
-export declare function partial<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
-export declare function pick<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
-export declare function omit<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function partial<T extends Record>(schema: ObjectSchemaOrType<T>): ObjectSchema<Partial<T>>;
+export declare function partial<T extends Record, K extends keyof T>(schema: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+export declare function pick<T extends Record, K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function omit<T extends Record, K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
 export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
 declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | null;
+export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
+export declare function Record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
 export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
 export {};

package/schema/schemas/object.js

@@ -6,6 +6,7 @@ import { memoizeSingle } from '../../utils/function/memoize.js';
 import { filterObject, mapObjectValues, objectKeys } from '../../utils/object/object.js';
 import { assert, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 import { array } from './array.js';
@@ -79,21 +80,15 @@ export function record(key, value, options) {
     return object({}, { ...options, unknownPropertiesKey: key, unknownProperties: value });
 }
 export function assign(...schemasOrTypes) {
-    const schemas = schemasOrTypes.map((schemaOrType) => {
-        if (schemaOrType instanceof ObjectSchema) {
-            return schemaOrType;
-        }
-        const typeSchema = getSchemaFromReflection(schemaOrType);
-        assert(typeSchema instanceof ObjectSchema, 'assign() only works with object schemas.');
-        return typeSchema;
-    });
+    const schemas = schemasOrTypes.map(getObjectSchema);
     return object(schemas.reduce((result, schema) => ({ ...result, ...schema.properties }), {}), {
         mask: schemas.findLast((schema) => isNotNull(schema.mask))?.mask,
         unknownProperties: schemas.findLast((schema) => isNotNull(schema.unknownProperties))?.unknownProperties,
         unknownPropertiesKey: schemas.findLast((schema) => isNotNull(schema.unknownPropertiesKey))?.unknownPropertiesKey
     });
 }
-export function partial(schema, keyOrKeys) {
+export function partial(schemaOrType, keyOrKeys) {
+    const schema = getObjectSchema(schemaOrType);
     const keys = isUndefined(keyOrKeys) ? undefined : toArray(keyOrKeys);
     const mapper = isUndefined(keys)
         ? (propertySchema) => optional(propertySchema)
@@ -104,7 +99,8 @@ export function partial(schema, keyOrKeys) {
         unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
-export function pick(schema, keys) {
+export function pick(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
     const keyArray = toArray(keys);
     return object(filterObject(schema.properties, (_, key) => keyArray.includes(key)), {
         mask: schema.mask,
@@ -112,7 +108,8 @@ export function pick(schema, keys) {
         unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
-export function omit(schema, keys) {
+export function omit(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
     const keysArray = toArray(keys);
     return object(filterObject(schema.properties, (_, key) => !keysArray.includes(key)), {
         mask: schema.mask,
@@ -174,4 +171,16 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     }
     return properties;
 }
+export function getObjectSchema(schemaOrType) {
+    if (schemaOrType instanceof ObjectSchema) {
+        return schemaOrType;
+    }
+    if (isFunction(schemaOrType)) {
+        return getObjectSchema(getSchemaFromReflection(schemaOrType));
+    }
+    throw new Error('Could not infer ObjectSchema.');
+}
+export function Record(key, value, options) {
+    return Property(record(key, value, options), options);
+}
 export const emptyObjectSchema = explicitObject({});

package/schema/schemas/optional.d.ts

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

package/schema/schemas/optional.js

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

package/schema/schemas/symbol.d.ts

@@ -1,12 +1,12 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator } from '../decorators/index.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> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<symbol>;
 }
 export declare function symbol(): SymbolSchema;
-export declare function Symbol(): SchemaPropertyDecorator;
+export declare function Symbol(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
 /**
  * @deprecated use {@link Symbol()} instead
  */
-export declare function SymbolProperty(): SchemaPropertyDecorator;
+export declare function SymbolProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/symbol.js

@@ -14,12 +14,12 @@ export class SymbolSchema extends Schema {
 export function symbol() {
     return new SymbolSchema();
 }
-export function Symbol() {
-    return Property(symbol());
+export function Symbol(options) {
+    return Property(symbol(), options);
 }
 /**
  * @deprecated use {@link Symbol()} instead
  */
-export function SymbolProperty() {
-    return Symbol();
+export function SymbolProperty(options) {
+    return Symbol(options);
 }