@tstdl/base 0.92.8 → 0.92.10

package/examples/document-management/main.js

@@ -1,7 +1,7 @@
 import '../../polyfills.js';
 import { Application } from '../../application/application.js';
-import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/module.js';
-import { DocumentManagementService } from '../../document-management/services/document-management.service.js';
+import { configureDocumentManagement, migrateDocumentManagementSchema } from '../../document-management/server/module.js';
+import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
 import { injectAsync } from '../../injector/inject.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
 async function bootstrap() {

package/examples/orm/schemas.d.ts

@@ -1,3 +1,3 @@
 import { User } from './user.model.js';
-export declare const mySchema: import("../../orm/database-schema.js").DatabaseSchema<"my_application">;
-export declare const user: import("../../orm/drizzle/schema-converter.js").PgTableFromType<"my_application", typeof User>;
+export declare const mySchema: import("../../orm/server/database-schema.js").DatabaseSchema<"my_application">;
+export declare const user: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"my_application", typeof User>;

package/examples/orm/schemas.js

@@ -1,4 +1,4 @@
-import { databaseSchema } from '../../orm/database-schema.js';
+import { databaseSchema } from '../../orm/server/database-schema.js';
 import { User } from './user.model.js';
 export const mySchema = databaseSchema('my_application');
 export const user = mySchema.getTable(User);

package/orm/decorators.d.ts

@@ -1,6 +1,7 @@
-import type { PgIndexMethod } from 'drizzle-orm/pg-core';
+import type { LiteralUnion } from 'type-fest';
 import type { AbstractConstructor, TypedOmit } from '../types.js';
 import type { EntityType } from './entity.js';
+type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
 export type OrmTableReflectionData = {
     name?: string;
     unique?: UniqueReflectionData[];
@@ -32,7 +33,7 @@ export type IndexReflectionData = {
     columns?: (string | [string, 'asc' | 'desc'])[];
     order?: 'asc' | 'desc';
     options?: {
-        using?: PgIndexMethod;
+        using?: IndexMethod;
         unique?: boolean;
         nulls?: 'first' | 'last';
     };
@@ -48,3 +49,4 @@ export declare function Unique(name?: string, options?: UniqueReflectionData['op
 export declare function Unique(name: string | undefined, columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;
 export declare function Index(name?: string, options?: IndexReflectionData['options']): PropertyDecorator;
 export declare function Index(name: string | undefined, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
+export {};

package/orm/entity.d.ts

@@ -1,5 +1,5 @@
 import { Record } from '../schema/index.js';
-import { Type, TypedOmit, UntaggedDeep } from '../types.js';
+import type { Type, TypedOmit, UntaggedDeep } from '../types.js';
 import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
 export interface EntityType<T extends Entity = Entity> extends Type<T> {
     readonly entityName?: string;

package/orm/index.d.ts

@@ -1,8 +1,3 @@
-export * from './database-schema.js';
-export * from './database.js';
 export * from './entity.js';
-export * from './module.js';
 export * from './query.js';
-export * from './repository.js';
-export * from './transaction.js';
 export * from './types.js';

package/orm/index.js

@@ -1,8 +1,3 @@
-export * from './database-schema.js';
-export * from './database.js';
 export * from './entity.js';
-export * from './module.js';
 export * from './query.js';
-export * from './repository.js';
-export * from './transaction.js';
 export * from './types.js';

package/orm/schemas/json.d.ts

@@ -1,9 +1,9 @@
 import { type Decorator } from '../../reflection/index.js';
-import { ObjectSchema, type ObjectSchemaOptions, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+import { ObjectSchema, type ObjectSchemaOptions, type SchemaDecoratorOptions } from '../../schema/index.js';
 export type JsonSchemaOptions = Pick<ObjectSchemaOptions, 'factory'>;
 export declare class JsonSchema extends ObjectSchema {
     readonly name = "Json";
     constructor(options?: JsonSchemaOptions);
 }
 export declare function json(options?: JsonSchemaOptions): JsonSchema;
-export declare function Json(options?: JsonSchemaOptions & SchemaPropertyDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
+export declare function Json(options?: JsonSchemaOptions & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;

package/orm/schemas/numeric-date.d.ts

@@ -1,8 +1,8 @@
-import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions, type SimpleSchemaOptions } from '../../schema/index.js';
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaDecoratorOptions, type SimpleSchemaOptions } from '../../schema/index.js';
 export type NumericDateSchemaOptions = SimpleSchemaOptions<number> & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
 export declare class NumericDateSchema extends NumberSchema {
     readonly name = "NumericDate";
     constructor(options?: NumericDateSchemaOptions);
 }
 export declare function numericDate(options?: NumericDateSchemaOptions): NumericDateSchema;
-export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/timestamp.d.ts

@@ -1,5 +1,5 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions, type SchemaTestOptions, type SchemaTestResult, type SimpleSchemaOptions } from '../../schema/index.js';
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaDecoratorOptions, type SchemaTestOptions, type SchemaTestResult, type SimpleSchemaOptions } from '../../schema/index.js';
 export type TimestampSchemaOptions = SimpleSchemaOptions<number> & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
 export declare class TimestampSchema extends NumberSchema {
     readonly name = "Timestamp";
@@ -7,4 +7,4 @@ export declare class TimestampSchema extends NumberSchema {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<number>;
 }
 export declare function timestamp(options?: TimestampSchemaOptions): TimestampSchema;
-export declare function Timestamp(options?: TimestampSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Timestamp(options?: TimestampSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/uuid.d.ts

@@ -1,4 +1,4 @@
-import { StringSchema, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+import { StringSchema, type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../../schema/index.js';
 export type UuidSchemaOptions = {
     defaultRandom?: boolean;
 };
@@ -8,4 +8,4 @@ export declare class UuidSchema extends StringSchema {
     constructor(options?: UuidSchemaOptions);
 }
 export declare function uuid(options?: UuidSchemaOptions): UuidSchema;
-export declare function Uuid(options?: UuidSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uuid(options?: UuidSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/{database-schema.d.ts → server/database-schema.d.ts}

@@ -1,7 +1,7 @@
 import type { PgEnum } from 'drizzle-orm/pg-core';
-import type { Enumeration, EnumerationValue, UnionToTuple } from '../types.js';
+import type { Enumeration, EnumerationValue, UnionToTuple } from '../../types.js';
 import { type PgTableFromType } from './drizzle/schema-converter.js';
-import type { EntityType } from './entity.js';
+import type { EntityType } from '../entity.js';
 export declare class DatabaseSchema<Name extends string> {
     readonly name: Name;
     constructor(name: Name);

package/orm/{database.d.ts → server/database.d.ts}

@@ -1,5 +1,5 @@
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
+import { Resolvable, type resolveArgumentType } from '../../injector/interfaces.js';
 import { DatabaseArgument } from './module.js';
 export declare class Database extends NodePgDatabase<any> implements Resolvable<DatabaseArgument> {
     readonly [resolveArgumentType]?: DatabaseArgument;

package/orm/{database.js → server/database.js}

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { ReplaceClass } from '../injector/decorators.js';
+import { ReplaceClass } from '../../injector/decorators.js';
 let Database = class Database extends NodePgDatabase {
 };
 Database = __decorate([

package/orm/{drizzle → server/drizzle}/schema-converter.d.ts

@@ -1,12 +1,12 @@
 import type { BuildColumns, NotNull } from 'drizzle-orm';
 import { type PgColumnBuilder, type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
 import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
-import { JsonPath } from '../../json-path/json-path.js';
-import { type Record } from '../../schema/index.js';
-import type { AbstractConstructor, Enumeration } from '../../types.js';
-import type { OrmColumnReflectionData } from '../decorators.js';
-import type { EntityType } from '../entity.js';
-import type { ColumnBuilder, embedded } from '../types.js';
+import { JsonPath } from '../../../json-path/json-path.js';
+import { type Record } from '../../../schema/index.js';
+import type { AbstractConstructor, Enumeration } from '../../../types.js';
+import type { OrmColumnReflectionData } from '../../decorators.js';
+import type { EntityType } from '../../entity.js';
+import type { ColumnBuilder, embedded } from '../../types.js';
 type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
 type ConverterContext = {
     type: AbstractConstructor;

package/orm/{drizzle → server/drizzle}/schema-converter.js

@@ -1,20 +1,20 @@
 import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
 import { boolean, date, doublePrecision, index, integer, jsonb, pgSchema, text, timestamp, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
-import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
-import { NotSupportedError } from '../../errors/not-supported.error.js';
-import { JsonPath } from '../../json-path/json-path.js';
-import { reflectionRegistry } from '../../reflection/registry.js';
-import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema } from '../../schema/index.js';
-import { compareByValueSelectionToOrder, orderRest } from '../../utils/comparison.js';
-import { enumValues } from '../../utils/enum.js';
-import { memoize, memoizeSingle } from '../../utils/function/memoize.js';
-import { compileDereferencer } from '../../utils/object/dereference.js';
-import { fromEntries, objectEntries } from '../../utils/object/object.js';
-import { assertDefined, assertDefinedPass, isArray, isDefined, isNull, isString, isUndefined } from '../../utils/type-guards.js';
-import { JsonSchema } from '../schemas/json.js';
-import { NumericDateSchema } from '../schemas/numeric-date.js';
-import { TimestampSchema } from '../schemas/timestamp.js';
-import { UuidSchema } from '../schemas/uuid.js';
+import { MultiKeyMap } from '../../../data-structures/multi-key-map.js';
+import { NotSupportedError } from '../../../errors/not-supported.error.js';
+import { JsonPath } from '../../../json-path/json-path.js';
+import { reflectionRegistry } from '../../../reflection/registry.js';
+import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema } from '../../../schema/index.js';
+import { compareByValueSelectionToOrder, orderRest } from '../../../utils/comparison.js';
+import { enumValues } from '../../../utils/enum.js';
+import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
+import { compileDereferencer } from '../../../utils/object/dereference.js';
+import { fromEntries, objectEntries } from '../../../utils/object/object.js';
+import { assertDefined, assertDefinedPass, isArray, isDefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { JsonSchema } from '../../schemas/json.js';
+import { NumericDateSchema } from '../../schemas/numeric-date.js';
+import { TimestampSchema } from '../../schemas/timestamp.js';
+import { UuidSchema } from '../../schemas/uuid.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
 const columnDefinitionsSymbol = Symbol('columnDefinitions');

package/orm/server/index.d.ts

@@ -0,0 +1,6 @@
+export * from './database-schema.js';
+export * from './database.js';
+export * from './module.js';
+export * from './query-converter.js';
+export * from './repository.js';
+export * from './transaction.js';

package/orm/server/index.js

@@ -0,0 +1,6 @@
+export * from './database-schema.js';
+export * from './database.js';
+export * from './module.js';
+export * from './query-converter.js';
+export * from './repository.js';
+export * from './transaction.js';

package/orm/{module.d.ts → server/module.d.ts}

@@ -3,4 +3,4 @@ export type DatabaseConfig = {
     connection: DatabaseArgument;
 };
 export type DatabaseArgument = string | PoolConfig;
-export declare const DATABASE_CONFIG: import("../injector/index.js").InjectionToken<DatabaseConfig, never>;
+export declare const DATABASE_CONFIG: import("../../injector/index.js").InjectionToken<DatabaseConfig, never>;

package/orm/{module.js → server/module.js}

@@ -1,7 +1,7 @@
 import { drizzle } from 'drizzle-orm/node-postgres';
-import { inject, injectionToken } from '../injector/index.js';
-import { Injector } from '../injector/injector.js';
-import { isUndefined } from '../utils/type-guards.js';
+import { inject, injectionToken } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { isUndefined } from '../../utils/type-guards.js';
 import { Database } from './database.js';
 export const DATABASE_CONFIG = injectionToken('EntityRepositoryConfig');
 Injector.registerSingleton(Database, {

package/orm/{query-converter.d.ts → server/query-converter.d.ts}

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
 import type { ColumnDefinition, PgTableFromType } from './drizzle/schema-converter.js';
-import type { EntityType } from './entity.js';
-import type { Query } from './query.js';
+import type { EntityType } from '../entity.js';
+import type { Query } from '../query.js';
 export declare function convertQuery(query: Query, table: PgTableFromType<string, EntityType>, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;

package/orm/{query-converter.js → server/query-converter.js}

@@ -1,7 +1,7 @@
 import { and, eq, gt, gte, inArray, isNotNull, isNull, isSQLWrapper, lt, lte, ne, not, notInArray, or, SQL, sql } from 'drizzle-orm';
-import { NotSupportedError } from '../errors/not-supported.error.js';
-import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
-import { assertDefinedPass, isPrimitive, isRegExp, isString, isUndefined } from '../utils/type-guards.js';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { hasOwnProperty, objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
 const sqlTrue = sql `true`;
 export function convertQuery(query, table, columnDefinitionsMap) {
     if (query instanceof SQL) {

package/orm/{repository.d.ts → server/repository.d.ts}

@@ -1,12 +1,12 @@
 import { SQL } from 'drizzle-orm';
 import { PgTransaction as DrizzlePgTransaction, PgColumn, PgInsertValue, PgQueryResultHKT, PgUpdateSetSource } from 'drizzle-orm/pg-core';
 import { PartialDeep } from 'type-fest';
-import { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Record, Type, TypedOmit, UntaggedDeep } from '../types.js';
+import { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import type { DeepPartial, OneOrMany, Paths, Record, Type, TypedOmit, UntaggedDeep } from '../../types.js';
 import { Database } from './database.js';
 import { ColumnDefinition, type PgTableFromType } from './drizzle/schema-converter.js';
-import type { Entity, EntityMetadata, EntityMetadataAttributes, EntityType, NewEntity } from './entity.js';
-import type { Query } from './query.js';
+import type { Entity, EntityMetadata, EntityMetadataAttributes, EntityType, NewEntity } from '../entity.js';
+import type { Query } from '../query.js';
 import { Transaction, TransactionConfig } from './transaction.js';
 type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;

package/orm/{repository.js → server/repository.js}

@@ -10,13 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { count, eq, inArray, sql } from 'drizzle-orm';
 import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
-import { NotFoundError } from '../errors/not-found.error.js';
-import { Singleton } from '../injector/decorators.js';
-import { inject, injectArgument } from '../injector/inject.js';
-import { Schema } from '../schema/schema.js';
-import { toArray } from '../utils/array/array.js';
-import { fromDeepObjectEntries } from '../utils/object/object.js';
-import { assertDefinedPass, assertNotNullPass, isNotNull, isUndefined } from '../utils/type-guards.js';
+import { NotFoundError } from '../../errors/not-found.error.js';
+import { Singleton } from '../../injector/decorators.js';
+import { inject, injectArgument } from '../../injector/inject.js';
+import { Schema } from '../../schema/schema.js';
+import { toArray } from '../../utils/array/array.js';
+import { fromDeepObjectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, assertNotNullPass, isNotNull, isUndefined } from '../../utils/type-guards.js';
 import { Database } from './database.js';
 import { getColumnDefinitions, getDrizzleTableFromType } from './drizzle/schema-converter.js';
 import { convertQuery } from './query-converter.js';

package/orm/{transaction.d.ts → server/transaction.d.ts}

@@ -1,4 +1,4 @@
-import { DeferredPromise } from '../promise/deferred-promise.js';
+import { DeferredPromise } from '../../promise/deferred-promise.js';
 import type { PgTransaction as DrizzlePgTransaction, PgTransactionConfig } from 'drizzle-orm/pg-core';
 import type { Database } from './database.js';
 type PgTransaction = DrizzlePgTransaction<any, any, any>;

package/orm/{transaction.js → server/transaction.js}

@@ -1,4 +1,4 @@
-import { DeferredPromise } from '../promise/deferred-promise.js';
+import { DeferredPromise } from '../../promise/deferred-promise.js';
 import { Subject } from 'rxjs';
 export class Transaction {
     #afterCommitSubject = new Subject();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.8",
+  "version": "0.92.10",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -13,8 +13,8 @@
     "build:production:copy-files": "cp package.json .eslintrc.json tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && npm run copy:document-management",
     "build:docs": "typedoc",
     "build:docs:watch": "typedoc --watch",
-    "generate:drizzle": "drizzle-kit generate --config dist/document-management/drizzle.config.js",
-    "copy:document-management": "rm -rf ./dist/document-management/drizzle && cp -r ./source/document-management/drizzle ./dist/document-management/",
+    "generate:drizzle": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
+    "copy:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
     "lint": "eslint --config .eslintrc.json --cache source/",
     "pub": "npm run build:production && rm -vf dist/test* && rm -vrf dist/tools/ && npm publish dist/",
     "tsc:watch": "tsc --watch",
@@ -46,6 +46,7 @@
     "./disposable": "./disposable/index.js",
     "./distributed-loop": "./distributed-loop/index.js",
     "./dom": "./dom/index.js",
+    "./document-management": "./document-management/index.js",
     "./enumerable": "./enumerable/index.js",
     "./errors": "./errors/index.js",
     "./file": "./file/index.js",
@@ -72,6 +73,7 @@
     "./object-storage": "./object-storage/index.js",
     "./openid-connect": "./openid-connect/index.js",
     "./orm": "./orm/index.js",
+    "./orm/server": "./orm/server/index.js",
     "./password": "./password/index.js",
     "./pdf": "./pdf/index.js",
     "./pool": "./pool/index.js",
@@ -119,11 +121,11 @@
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.31"
+    "type-fest": "4.32"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "2.12",
+    "@stylistic/eslint-plugin": "2.13",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -148,7 +150,7 @@
     "@elastic/elasticsearch": "^8.17",
     "@google/generative-ai": "^0.21",
     "@koa/router": "^13.1",
-    "@tstdl/angular": "^0.91",
+    "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",

package/reflection/registry.js

@@ -40,13 +40,13 @@ export class ReflectionRegistry {
             return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
         }
         else if (data.type == 'method-parameter') {
-            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey);
+            return (data.static ? metadata.staticMethods : metadata.methods).get(data.methodKey).parameters.at(data.index);
         }
         else if (data.type == 'constructor-parameter') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
             if (isUndefined(metadata.parameters)) {
                 throw new Error('Constructor parameters are not available. (missing decoration?)');
             }
-            return metadata.parameters[data.index];
+            return metadata.parameters.at(data.index);
         }
         throw new Error(`Unknown DecoratorData type ${data.type}`);
     }

package/reflection/utils.d.ts

@@ -1,8 +1,6 @@
 import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, OneOrMany, PropertiesOfType, Record, TypedOmit } from '../types.js';
 import type { CombinedDecoratorParameters, Decorator, DecoratorData, DecoratorHandler, DecoratorMetadata, DecoratorType, DecoratorUnion } from './types.js';
-export type CreateDecoratorTypeOptions = {
-    [P in DecoratorType]?: boolean;
-};
+export type CreateDecoratorTypeOptions = Partial<Record<DecoratorType, boolean>>;
 export type CreateDecoratorOptions = {
     data?: Record<string | symbol>;
     /** Merge data values instead of replacing them (requires them to be objects, arrays, maps or sets) */

package/schema/decorators/index.d.ts

@@ -1,4 +1,3 @@
 export * from './class.js';
-export * from './property.js';
-export * from './types.js';
-export * from './utils.js';
+export * from './schema.js';
+export type * from './types.js';

package/schema/decorators/index.js

@@ -1,4 +1,2 @@
 export * from './class.js';
-export * from './property.js';
-export * from './types.js';
-export * from './utils.js';
+export * from './schema.js';

package/schema/decorators/schema.d.ts

@@ -0,0 +1,21 @@
+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 { CombinedSchemaDecorator, SchemaReflectionData, SchemaTestableProvider } from './types.js';
+export type SchemaDecoratorOptions = SchemaReflectionData;
+export type SchemaDecoratorOptionsWithRequiredSchema = SetRequired<SchemaReflectionData, 'schema'>;
+export type SchemaDecoratorOptionsWithoutSchema = TypedOmit<SchemaReflectionData, 'schema'>;
+export declare function createSchemaDecorator(data?: SchemaReflectionData): CombinedSchemaDecorator;
+export declare function SchemaDecorator(schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;
+export declare function SchemaDecorator(options: SchemaDecoratorOptionsWithRequiredSchema): CombinedSchemaDecorator;
+export declare function Parameter(name: string, schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): Decorator<'parameter'>;
+export declare function Parameter(name: string, options: SchemaDecoratorOptions): Decorator<'parameter'>;
+export declare const Property: typeof SchemaDecorator;
+/**
+ * @deprecated use @Property instead
+ * @param schemaTestableProvider
+ * @param options
+ * @returns
+ */
+export declare function PropertySchema(schemaTestableProvider: SchemaTestableProvider, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;

package/schema/decorators/schema.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createDecorator } from '../../reflection/index.js';
+import { filterUndefinedObjectProperties } from '../../utils/object/object.js';
+import { isSchemaTestable } from '../testable.js';
+export function createSchemaDecorator(data = {}) {
+    return createDecorator({
+        property: true,
+        accessor: true,
+        method: true,
+        parameter: true,
+        data: { schema: filterUndefinedObjectProperties(data) },
+        mergeData: true
+    });
+}
+export function SchemaDecorator(schemaOrOptions, optionsOrNothing) {
+    if (isSchemaTestable(schemaOrOptions)) {
+        return createSchemaDecorator({ ...optionsOrNothing, schema: () => schemaOrOptions });
+    }
+    return createSchemaDecorator(schemaOrOptions);
+}
+export function Parameter(name, schemaOrOptions, optionsOrNothing) {
+    if (isSchemaTestable(schemaOrOptions)) {
+        return createSchemaDecorator({ ...optionsOrNothing, schema: () => schemaOrOptions, parameter: { name } });
+    }
+    return createSchemaDecorator({ ...schemaOrOptions, parameter: { name } });
+}
+export const Property = SchemaDecorator;
+/**
+ * @deprecated use @Property instead
+ * @param schemaTestableProvider
+ * @param options
+ * @returns
+ */
+export function PropertySchema(schemaTestableProvider, options) {
+    return SchemaDecorator({ ...options, schema: schemaTestableProvider });
+}

package/schema/decorators/types.d.ts

@@ -3,14 +3,22 @@ import type { SchemaOptions, SchemaTestable } from '../schema.js';
 import type { ObjectSchemaFactory, ObjectSchemaOptions } from '../schemas/object.js';
 export type SchemaClassDecorator = Decorator<'class'>;
 export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
+export type SchemaMethodDecorator = Decorator<'method'>;
+export type CombinedSchemaDecorator = Decorator<'property' | 'accessor' | 'parameter'>;
 export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey' | 'description' | 'example'>> & {
     schema?: SchemaTestable;
     factory?: ObjectSchemaFactory<any>;
 };
-export type SchemaTestableProvider = (data: SchemaPropertyReflectionData) => SchemaTestable;
-export type SchemaPropertyReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
+export type SchemaTestableProvider = (data: SchemaReflectionData) => SchemaTestable;
+export type SchemaReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
     schema?: SchemaTestableProvider;
     array?: boolean;
     optional?: boolean;
     nullable?: boolean;
+    method?: {
+        returnType?: SchemaTestableProvider;
+    };
+    parameter?: {
+        name?: string;
+    };
 };

package/schema/decorators/utils.d.ts

@@ -1,2 +1,7 @@
-import type { SchemaPropertyDecorator, SchemaPropertyReflectionData } from './types.js';
-export declare function createSchemaPropertyDecorator(data?: SchemaPropertyReflectionData): SchemaPropertyDecorator;
+import type { AbstractConstructor } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { SchemaReflectionData } from './types.js';
+export declare function schemaReflectionDataToSchema(reflectionData: SchemaReflectionData | undefined, fallbackType: AbstractConstructor | null, source: {
+    type: AbstractConstructor;
+    key: string | symbol;
+}): SchemaTestable;

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;