@tstdl/base 0.72.0-beta1 → 0.78.0-beta11

package/schema/transformers/lowercase.d.ts

@@ -0,0 +1,9 @@
+import type { Decorator } from "../../reflection";
+import type { TransformResult } from '../types';
+import { SchemaValueTransformer } from '../types';
+export declare class LowercaseTransformer extends SchemaValueTransformer<string, string, string> {
+    readonly sourceType: StringConstructor;
+    readonly targetType: StringConstructor;
+    transform(value: string): TransformResult<string>;
+}
+export declare function Lowercase(): Decorator<'property' | 'accessor'>;

package/schema/transformers/lowercase.js

@@ -0,0 +1,22 @@
+"use strict";
+/* eslint-disable @typescript-eslint/naming-convention */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lowercase = exports.LowercaseTransformer = void 0;
+const decorators_1 = require("../decorators");
+const types_1 = require("../types");
+class LowercaseTransformer extends types_1.SchemaValueTransformer {
+    constructor() {
+        super(...arguments);
+        this.sourceType = String;
+        this.targetType = String;
+    }
+    transform(value) {
+        return { success: true, value: value.toLowerCase() };
+    }
+}
+exports.LowercaseTransformer = LowercaseTransformer;
+function Lowercase() {
+    return (0, decorators_1.createSchemaValueTransformerDecorator)(new LowercaseTransformer(), { schema: (0, types_1.typeSchema)(String) });
+}
+exports.Lowercase = Lowercase;
+//# sourceMappingURL=lowercase.js.map

package/schema/transformers/lowercase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowercase.js","sourceRoot":"","sources":["../../../source/schema/transformers/lowercase.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAGzD,8CAAsE;AAEtE,oCAA8D;AAE9D,MAAa,oBAAqB,SAAQ,8BAA8C;IAAxF;;QACW,eAAU,GAAG,MAAM,CAAC;QACpB,eAAU,GAAG,MAAM,CAAC;IAK/B,CAAC;IAHC,SAAS,CAAC,KAAa;QACrB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;IACvD,CAAC;CACF;AAPD,oDAOC;AAED,SAAgB,SAAS;IACvB,OAAO,IAAA,kDAAqC,EAAC,IAAI,oBAAoB,EAAE,EAAE,EAAE,MAAM,EAAE,IAAA,kBAAU,EAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC3G,CAAC;AAFD,8BAEC"}

package/schema/transformers/trim.d.ts

@@ -0,0 +1,9 @@
+import type { Decorator } from "../../reflection";
+import type { TransformResult } from '../types';
+import { SchemaValueTransformer } from '../types';
+export declare class TrimTransformer extends SchemaValueTransformer<string, string, string> {
+    readonly sourceType: StringConstructor;
+    readonly targetType: StringConstructor;
+    transform(value: string): TransformResult<string>;
+}
+export declare function Trim(): Decorator<'property' | 'accessor'>;

package/schema/transformers/trim.js

@@ -0,0 +1,22 @@
+"use strict";
+/* eslint-disable @typescript-eslint/naming-convention */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trim = exports.TrimTransformer = void 0;
+const decorators_1 = require("../decorators");
+const types_1 = require("../types");
+class TrimTransformer extends types_1.SchemaValueTransformer {
+    constructor() {
+        super(...arguments);
+        this.sourceType = String;
+        this.targetType = String;
+    }
+    transform(value) {
+        return { success: true, value: value.trim() };
+    }
+}
+exports.TrimTransformer = TrimTransformer;
+function Trim() {
+    return (0, decorators_1.createSchemaValueTransformerDecorator)(new TrimTransformer(), { schema: (0, types_1.typeSchema)(String) });
+}
+exports.Trim = Trim;
+//# sourceMappingURL=trim.js.map

package/schema/transformers/trim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim.js","sourceRoot":"","sources":["../../../source/schema/transformers/trim.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAGzD,8CAAsE;AAEtE,oCAA8D;AAE9D,MAAa,eAAgB,SAAQ,8BAA8C;IAAnF;;QACW,eAAU,GAAG,MAAM,CAAC;QACpB,eAAU,GAAG,MAAM,CAAC;IAK/B,CAAC;IAHC,SAAS,CAAC,KAAa;QACrB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;IAChD,CAAC;CACF;AAPD,0CAOC;AAED,SAAgB,IAAI;IAClB,OAAO,IAAA,kDAAqC,EAAC,IAAI,eAAe,EAAE,EAAE,EAAE,MAAM,EAAE,IAAA,kBAAU,EAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACtG,CAAC;AAFD,oBAEC"}

package/schema/transformers/uppercase.d.ts

@@ -0,0 +1,9 @@
+import type { Decorator } from "../../reflection";
+import type { TransformResult } from '../types';
+import { SchemaValueTransformer } from '../types';
+export declare class UppercaseTransformer extends SchemaValueTransformer<string, string, string> {
+    readonly sourceType: StringConstructor;
+    readonly targetType: StringConstructor;
+    transform(value: string): TransformResult<string>;
+}
+export declare function Uppercase(): Decorator<'property' | 'accessor'>;

package/schema/transformers/uppercase.js

@@ -0,0 +1,22 @@
+"use strict";
+/* eslint-disable @typescript-eslint/naming-convention */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uppercase = exports.UppercaseTransformer = void 0;
+const decorators_1 = require("../decorators");
+const types_1 = require("../types");
+class UppercaseTransformer extends types_1.SchemaValueTransformer {
+    constructor() {
+        super(...arguments);
+        this.sourceType = String;
+        this.targetType = String;
+    }
+    transform(value) {
+        return { success: true, value: value.toUpperCase() };
+    }
+}
+exports.UppercaseTransformer = UppercaseTransformer;
+function Uppercase() {
+    return (0, decorators_1.createSchemaValueTransformerDecorator)(new UppercaseTransformer(), { schema: (0, types_1.typeSchema)(String) });
+}
+exports.Uppercase = Uppercase;
+//# sourceMappingURL=uppercase.js.map

package/schema/transformers/uppercase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uppercase.js","sourceRoot":"","sources":["../../../source/schema/transformers/uppercase.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAGzD,8CAAsE;AAEtE,oCAA8D;AAE9D,MAAa,oBAAqB,SAAQ,8BAA8C;IAAxF;;QACW,eAAU,GAAG,MAAM,CAAC;QACpB,eAAU,GAAG,MAAM,CAAC;IAK/B,CAAC;IAHC,SAAS,CAAC,KAAa;QACrB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;IACvD,CAAC;CACF;AAPD,oDAOC;AAED,SAAgB,SAAS;IACvB,OAAO,IAAA,kDAAqC,EAAC,IAAI,oBAAoB,EAAE,EAAE,EAAE,MAAM,EAAE,IAAA,kBAAU,EAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC3G,CAAC;AAFD,8BAEC"}

package/schema/types.d.ts

@@ -1,30 +1,168 @@
-import type { Simplify, TypedOmit } from "../types.js";
-import type { SchemaValidator } from './schema.validator.js';
-declare const schemaTypes: unique symbol;
-export declare type SchemaDefinition<Type extends string = string, Input = unknown, Output = unknown> = {
-    type: Type;
-    [schemaTypes]?: {
-        input: Input;
-        output: Output;
-    };
-};
-export declare type Schema<T> = SchemaValidator<SchemaDefinition<string, unknown, T>>;
-export declare type SchemaOptions<T extends SchemaDefinition, K extends keyof T = never> = Simplify<Partial<TypedOmit<T, keyof SchemaDefinition | K>>>;
-export declare type SchemaInput<T extends SchemaDefinition | SchemaValidator> = T extends SchemaDefinition<string, infer I, any> ? I : T extends SchemaValidator ? T['inputType'] : never;
-export declare type SchemaOutput<T extends SchemaDefinition | SchemaValidator> = T extends SchemaDefinition<string, any, infer O> ? O : T extends SchemaValidator ? T['outputType'] : never;
+import type { JsonPath } from "../json-path/json-path";
+import type { AbstractConstructor, OneOrMany, Record, Type, TypedOmit } from "../types";
+import type { NormalizedSchema, Schema } from './schema';
+import type { SchemaError } from './schema.error';
+declare const schemaOutputTypeSymbol: unique symbol;
+export declare type SchemaFactoryFunction<T extends Record, O = T> = (data: T) => NormalizeValueType<O>;
+export declare type SchemaFactory<T extends Record, O = T> = {
+    type: Type<T>;
+    builder?: undefined;
+} | {
+    type?: undefined;
+    builder: SchemaFactoryFunction<T, O>;
+};
+export declare type ObjectSchemaProperties<T extends Record> = {
+    [K in keyof T]-?: OneOrMany<Schema<any, T[K]>>;
+};
+export declare type NormalizedObjectSchemaProperties<T> = {
+    [K in keyof T]-?: Schema<any, T[K]>;
+};
+export declare type SchemaOutput<T extends Schema> = T extends ObjectSchema<any, infer O> ? O : T extends ValueSchema<any, infer O> ? O : T extends TypeSchema<infer O> ? O : never;
+export declare type ObjectSchema<T extends Record = any, O extends Record = T> = {
+    [schemaOutputTypeSymbol]?: O;
+    sourceType?: ValueType;
+    factory?: SchemaFactory<T, O>;
+    properties: ObjectSchemaProperties<T>;
+    mask?: boolean;
+    allowUnknownProperties?: OneOrMany<Schema>;
+};
+export declare type TypeSchema<T = any> = {
+    type: ValueType<T>;
+};
+export declare type NormalizedTypeSchema<T = any> = {
+    foo: ResolvedValueType<T>;
+};
+export declare type ValueSchema<T = unknown, O = T> = {
+    [schemaOutputTypeSymbol]?: O;
+    schema: OneOrMany<Schema<T, O>>;
+    array?: boolean;
+    optional?: boolean;
+    nullable?: boolean;
+    /** use default coercers */
+    coerce?: boolean;
+    /** custom coercers */
+    coercers?: OneOrMany<SchemaValueCoercer>;
+    transformers?: OneOrMany<SchemaValueTransformer>;
+    arrayConstraints?: OneOrMany<SchemaArrayConstraint>;
+    valueConstraints?: OneOrMany<SchemaValueConstraint>;
+};
+export declare type NormalizedObjectSchema<T extends Record = any, O extends Record = T> = {
+    [schemaOutputTypeSymbol]?: O;
+    factory?: SchemaFactory<T, O>;
+    properties: NormalizedObjectSchemaProperties<T>;
+    mask?: boolean;
+    allowUnknownProperties: Set<Schema>;
+};
+export declare type NormalizedValueSchema<T = any, O = T> = {
+    [schemaOutputTypeSymbol]?: O;
+    schema: Set<Schema<T, O>>;
+    array: boolean;
+    optional: boolean;
+    nullable: boolean;
+    coerce: boolean;
+    coercers: Map<ValueType, SchemaValueCoercer[]>;
+    transformers: readonly SchemaValueTransformer<any, any, any>[];
+    arrayConstraints: readonly SchemaArrayConstraint[];
+    valueConstraints: readonly SchemaValueConstraint[];
+};
+export declare type SchemaContext = {
+    schema: NormalizedSchema;
+    options: SchemaTestOptions;
+};
+export declare type ConstraintContext = SchemaContext;
+export declare type TransformerContext = SchemaContext;
+export declare type CoercerContext = SchemaContext;
+export declare type NormalizeValueType<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends BigInt ? bigint : T extends Symbol ? symbol : T extends 'undefined' ? undefined : T extends 'null' ? null : T extends 'any' ? any : T;
+export declare type NormalizeToValueType<T> = T extends string | String ? typeof String : T extends number ? typeof Number : T extends boolean ? typeof Boolean : T extends bigint ? typeof BigInt : T extends symbol ? typeof Symbol : T extends undefined ? 'undefined' : T extends null ? 'null' : T extends any ? 'any' : never;
+export declare type ValueType<T = any> = AbstractConstructor<T> | NormalizeToValueType<T> | DeferredValueType<T>;
+export declare type DeferredValueType<T = unknown> = {
+    deferred: () => ValueType<T>;
+};
+export declare type ResolvedValueType<T = unknown> = Exclude<ValueType<T>, DeferredValueType>;
+export declare type ValueTypeOutput<T extends ValueType> = T extends ValueType<infer U> ? NormalizeValueType<U> : never;
 export declare type Coercible = {
+    coerce?: boolean;
+};
+export declare const primitiveConstructors: ValueType[];
+export declare const primitiveConstructorSet: Set<ValueType<any>>;
+export declare abstract class SchemaArrayConstraint {
+    abstract validate(value: readonly unknown[], path: JsonPath, context: ConstraintContext): ConstraintResult;
+}
+export declare type OptionKeys<T extends Record> = readonly (keyof T)[];
+export declare abstract class SchemaValueConstraint {
+    abstract readonly suitableTypes: OneOrMany<ValueType>;
+    abstract readonly expects: OneOrMany<string>;
+    abstract validate(value: unknown, path: JsonPath, context: ConstraintContext): ConstraintResult;
+}
+export declare abstract class SchemaValueTransformer<T = any, O = T, TransformOutput = O> {
+    abstract readonly sourceType: OneOrMany<ValueType<T>>;
+    abstract readonly targetType: ValueType<TransformOutput>;
+    abstract transform(value: O, path: JsonPath, context: TransformerContext): TransformResult<TransformOutput>;
+}
+export declare abstract class SchemaValueCoercer {
+    abstract readonly sourceType: OneOrMany<ValueType>;
+    abstract readonly targetType: ValueType;
+    abstract coerce(value: unknown, path: JsonPath, context: CoercerContext): CoerceResult;
+}
+export declare type SchemaTestOptions = {
     /**
      * try to convert wrong input into desired output.
      * Can be specified on definition and validation. If specified on both, definition has higher priority
      */
     coerce?: boolean;
-};
-export declare type Maskable = {
     /**
      * remove unspecified fields on input data instead of raising an error.
      * Can be specified on definition and validation. If specified on both, definition has higher priority
      */
     mask?: boolean;
 };
-export declare function schemaHelper<T extends SchemaDefinition>(schema: TypedOmit<T, typeof schemaTypes>): T;
+export declare type SchemaTestResult<T> = {
+    valid: true;
+    value: T;
+    error?: undefined;
+} | {
+    valid: false;
+    value?: undefined;
+    error: SchemaError;
+};
+export declare type ConstraintResult = {
+    valid: true;
+    error?: undefined;
+} | {
+    valid: false;
+    error: SchemaError;
+};
+export declare type CoerceResult = {
+    success: true;
+    value: any;
+    error?: undefined;
+} | {
+    success: false;
+    value?: undefined;
+    error: SchemaError;
+};
+export declare type TransformResult<T> = {
+    success: true;
+    value: T;
+    error?: undefined;
+} | {
+    success: false;
+    value?: undefined;
+    error: SchemaError;
+};
+export declare function objectSchema<T, O = T>(schema: ObjectSchema<T, O>): ObjectSchema<T, O>;
+export declare function valueSchema<T, O = T>(schema: OneOrMany<Schema<T, O>>, options?: TypedOmit<ValueSchema<T, O>, 'schema'>): ValueSchema<T, O>;
+export declare function typeSchema<T>(type: ValueType<T>): TypeSchema<NormalizeValueType<T>>;
+export declare function isSchema<T extends Record, O extends Record>(value: any): value is Schema<T, O>;
+export declare function isObjectSchema<T extends Record, O extends Record>(schema: Schema<T, O>): schema is ObjectSchema<T, O>;
+export declare function isObjectSchema<T extends Record, O extends Record>(schema: any): schema is ObjectSchema<T, O>;
+export declare function isValueSchema<T, O>(schema: Schema<T, O>): schema is ValueSchema<T, O>;
+export declare function isValueSchema<T, O>(schema: any): schema is ValueSchema<T, O>;
+export declare function isTypeSchema<T, O>(schema: Schema<T, O>): schema is TypeSchema<O>;
+export declare function isTypeSchema<T, O>(schema: any): schema is TypeSchema<O>;
+export declare function isDeferredValueType<T>(value: ValueType<T>): value is DeferredValueType<T>;
+export declare function resolveValueTypes<T>(valueTypes: OneOrMany<ValueType<T>>): OneOrMany<ResolvedValueType<T>>;
+export declare function resolveValueType<T>(valueType: ValueType<T>): ResolvedValueType<T>;
+export declare function valueTypesOrSchemasToSchemas<T, O>(valueTypesOrSchemas: OneOrMany<ValueType<O> | Schema<T, O>>): OneOrMany<Schema<T, O>>;
+export declare function valueTypeOrSchemaToSchema<T, O>(valueTypeOrSchema: ValueType<O> | Schema<T, O>): Schema<T, O>;
 export {};

package/schema/types.js

@@ -1,4 +1,79 @@
-export function schemaHelper(schema) {
+"use strict";
+/* eslint-disable @typescript-eslint/ban-types */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueTypeOrSchemaToSchema = exports.valueTypesOrSchemasToSchemas = exports.resolveValueType = exports.resolveValueTypes = exports.isDeferredValueType = exports.isTypeSchema = exports.isValueSchema = exports.isObjectSchema = exports.isSchema = exports.typeSchema = exports.valueSchema = exports.objectSchema = exports.SchemaValueCoercer = exports.SchemaValueTransformer = exports.SchemaValueConstraint = exports.SchemaArrayConstraint = exports.primitiveConstructorSet = exports.primitiveConstructors = void 0;
+const type_guards_1 = require("../utils/type-guards");
+exports.primitiveConstructors = [String, Number, Boolean, Symbol, BigInt, Function, 'undefined', 'null'];
+exports.primitiveConstructorSet = new Set(exports.primitiveConstructors);
+class SchemaArrayConstraint {
+}
+exports.SchemaArrayConstraint = SchemaArrayConstraint;
+class SchemaValueConstraint {
+}
+exports.SchemaValueConstraint = SchemaValueConstraint;
+class SchemaValueTransformer {
+}
+exports.SchemaValueTransformer = SchemaValueTransformer;
+class SchemaValueCoercer {
+}
+exports.SchemaValueCoercer = SchemaValueCoercer;
+function objectSchema(schema) {
     return schema;
 }
+exports.objectSchema = objectSchema;
+function valueSchema(schema, options) {
+    return { schema, ...options };
+}
+exports.valueSchema = valueSchema;
+function typeSchema(type) {
+    return { type };
+}
+exports.typeSchema = typeSchema;
+function isSchema(value) {
+    return isObjectSchema(value) || isValueSchema(value) || isTypeSchema(value);
+}
+exports.isSchema = isSchema;
+function isObjectSchema(schema) {
+    return (0, type_guards_1.isObject)(schema?.properties);
+}
+exports.isObjectSchema = isObjectSchema;
+function isValueSchema(schema) {
+    return (0, type_guards_1.isObject)(schema) && (0, type_guards_1.isDefined)(schema?.schema);
+}
+exports.isValueSchema = isValueSchema;
+function isTypeSchema(schema) {
+    return (0, type_guards_1.isObject)(schema) && (0, type_guards_1.isFunction)(schema?.type);
+}
+exports.isTypeSchema = isTypeSchema;
+function isDeferredValueType(value) {
+    return (0, type_guards_1.isObject)(value) && (0, type_guards_1.isFunction)(value.deferred);
+}
+exports.isDeferredValueType = isDeferredValueType;
+function resolveValueTypes(valueTypes) {
+    if ((0, type_guards_1.isArray)(valueTypes)) {
+        return valueTypes.flatMap((valueType) => resolveValueTypes(valueType));
+    }
+    return resolveValueType(valueTypes);
+}
+exports.resolveValueTypes = resolveValueTypes;
+function resolveValueType(valueType) {
+    return isDeferredValueType(valueType)
+        ? resolveValueType(valueType.deferred())
+        : valueType;
+}
+exports.resolveValueType = resolveValueType;
+function valueTypesOrSchemasToSchemas(valueTypesOrSchemas) {
+    if ((0, type_guards_1.isArray)(valueTypesOrSchemas)) {
+        return valueTypesOrSchemas.map(valueTypeOrSchemaToSchema);
+    }
+    return valueTypeOrSchemaToSchema(valueTypesOrSchemas);
+}
+exports.valueTypesOrSchemasToSchemas = valueTypesOrSchemasToSchemas;
+function valueTypeOrSchemaToSchema(valueTypeOrSchema) {
+    if (isSchema(valueTypeOrSchema)) {
+        return valueTypeOrSchema;
+    }
+    return typeSchema(valueTypeOrSchema);
+}
+exports.valueTypeOrSchemaToSchema = valueTypeOrSchemaToSchema;
 //# sourceMappingURL=types.js.map

package/schema/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../source/schema/types.ts"],"names":[],"mappings":"AAwCA,MAAM,UAAU,YAAY,CAA6B,MAAwC;IAC/F,OAAO,MAAW,CAAC;AACrB,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../source/schema/types.ts"],"names":[],"mappings":";AAAA,iDAAiD;;;AAIjD,sDAA+E;AAgHlE,QAAA,qBAAqB,GAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAwC,EAAE,MAAwC,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;AAClL,QAAA,uBAAuB,GAAG,IAAI,GAAG,CAAC,6BAAqB,CAAC,CAAC;AAEtE,MAAsB,qBAAqB;CAE1C;AAFD,sDAEC;AAID,MAAsB,qBAAqB;CAK1C;AALD,sDAKC;AAED,MAAsB,sBAAsB;CAK3C;AALD,wDAKC;AAED,MAAsB,kBAAkB;CAKvC;AALD,gDAKC;AAgCD,SAAgB,YAAY,CAAW,MAA0B;IAC/D,OAAO,MAAM,CAAC;AAChB,CAAC;AAFD,oCAEC;AAED,SAAgB,WAAW,CAAW,MAA+B,EAAE,OAAgD;IACrH,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC;AAChC,CAAC;AAFD,kCAEC;AAED,SAAgB,UAAU,CAAI,IAAkB;IAC9C,OAAO,EAAE,IAAI,EAAuC,CAAC;AACvD,CAAC;AAFD,gCAEC;AAED,SAAgB,QAAQ,CAAqC,KAAU;IACrE,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,aAAa,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAFD,4BAEC;AAID,SAAgB,cAAc,CAAC,MAAW;IACxC,OAAO,IAAA,sBAAQ,EAAE,MAA4C,EAAE,UAAU,CAAC,CAAC;AAC7E,CAAC;AAFD,wCAEC;AAID,SAAgB,aAAa,CAAC,MAAW;IACvC,OAAO,IAAA,sBAAQ,EAAC,MAAM,CAAC,IAAI,IAAA,uBAAS,EAAE,MAAkC,EAAE,MAAM,CAAC,CAAC;AACpF,CAAC;AAFD,sCAEC;AAID,SAAgB,YAAY,CAAC,MAAW;IACtC,OAAO,IAAA,sBAAQ,EAAC,MAAM,CAAC,IAAI,IAAA,wBAAU,EAAE,MAAiC,EAAE,IAAI,CAAC,CAAC;AAClF,CAAC;AAFD,oCAEC;AAED,SAAgB,mBAAmB,CAAI,KAAmB;IACxD,OAAO,IAAA,sBAAQ,EAAC,KAAK,CAAC,IAAI,IAAA,wBAAU,EAAE,KAA2B,CAAC,QAAQ,CAAC,CAAC;AAC9E,CAAC;AAFD,kDAEC;AAED,SAAgB,iBAAiB,CAAI,UAAmC;IACtE,IAAI,IAAA,qBAAO,EAAC,UAAU,CAAC,EAAE;QACvB,OAAO,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC,CAAC;KACxE;IAED,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC;AACtC,CAAC;AAND,8CAMC;AAED,SAAgB,gBAAgB,CAAI,SAAuB;IACzD,OAAO,mBAAmB,CAAC,SAAS,CAAC;QACnC,CAAC,CAAC,gBAAgB,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QACxC,CAAC,CAAC,SAAiC,CAAC;AACxC,CAAC;AAJD,4CAIC;AAED,SAAgB,4BAA4B,CAAO,mBAA2D;IAC5G,IAAI,IAAA,qBAAO,EAAC,mBAAmB,CAAC,EAAE;QAChC,OAAO,mBAAmB,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;KAC3D;IAED,OAAO,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;AACxD,CAAC;AAND,oEAMC;AAED,SAAgB,yBAAyB,CAAO,iBAA8C;IAC5F,IAAI,QAAQ,CAAO,iBAAiB,CAAC,EAAE;QACrC,OAAO,iBAAiB,CAAC;KAC1B;IAED,OAAO,UAAU,CAAC,iBAAiB,CAAkB,CAAC;AACxD,CAAC;AAND,8DAMC"}

package/schema/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema';
+export * from './value-type';

package/schema/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schema"), exports);
+__exportStar(require("./value-type"), exports);
+//# sourceMappingURL=index.js.map

package/schema/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/schema/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,+CAA6B"}

package/schema/utils/schema.d.ts

@@ -0,0 +1,13 @@
+import type { NormalizedSchema, Schema } from '../schema';
+import type { NormalizedObjectSchema, NormalizedTypeSchema, NormalizedValueSchema, ObjectSchema, TypeSchema, ValueSchema } from '../types';
+export declare const normalizeSchema: typeof _normalizeSchema;
+export declare const normalizeObjectSchema: typeof _normalizeObjectSchema;
+export declare const normalizeValueSchema: typeof _normalizeValueSchema;
+export declare const normalizeTypeSchema: typeof _normalizeTypeSchema;
+export declare const getArrayItemSchema: typeof _getArrayItemSchema;
+declare function _normalizeSchema<T, O>(schema: Schema<T, O>): NormalizedSchema<T, O>;
+declare function _normalizeObjectSchema<T, O>(schema: ObjectSchema<T, O>): NormalizedObjectSchema<T, O>;
+declare function _normalizeValueSchema<T, O>(schema: ValueSchema<T, O>): NormalizedValueSchema<T, O>;
+declare function _normalizeTypeSchema<T>(schema: TypeSchema<T>): NormalizedTypeSchema<T>;
+declare function _getArrayItemSchema<T, O>(schema: ValueSchema<T, O>): ValueSchema<T, O>;
+export {};

package/schema/utils/schema.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayItemSchema = exports.normalizeTypeSchema = exports.normalizeValueSchema = exports.normalizeObjectSchema = exports.normalizeSchema = void 0;
+const array_1 = require("../../utils/array/array");
+const memoize_1 = require("../../utils/function/memoize");
+const object_1 = require("../../utils/object/object");
+const type_guards_1 = require("../../utils/type-guards");
+const types_1 = require("../types");
+exports.normalizeSchema = (0, memoize_1.memoizeSingle)(_normalizeSchema, { weak: true });
+exports.normalizeObjectSchema = (0, memoize_1.memoizeSingle)(_normalizeObjectSchema, { weak: true });
+exports.normalizeValueSchema = (0, memoize_1.memoizeSingle)(_normalizeValueSchema, { weak: true });
+exports.normalizeTypeSchema = (0, memoize_1.memoizeSingle)(_normalizeTypeSchema, { weak: true });
+exports.getArrayItemSchema = (0, memoize_1.memoizeSingle)(_getArrayItemSchema, { weak: true });
+function _normalizeSchema(schema) {
+    if ((0, types_1.isObjectSchema)(schema)) {
+        return (0, exports.normalizeObjectSchema)(schema);
+    }
+    if ((0, types_1.isValueSchema)(schema)) {
+        return (0, exports.normalizeValueSchema)(schema);
+    }
+    if ((0, types_1.isTypeSchema)(schema)) {
+        return (0, exports.normalizeTypeSchema)(schema);
+    }
+    throw new Error('Unsupported schema.');
+}
+function _normalizeObjectSchema(schema) {
+    const normalizedSchema = {
+        factory: schema.factory,
+        properties: (0, object_1.mapObjectValues)(schema.properties, (propertyValueType) => ((0, type_guards_1.isArray)(propertyValueType) ? (0, types_1.valueSchema)(propertyValueType) : propertyValueType)),
+        mask: schema.mask,
+        allowUnknownProperties: new Set((0, array_1.toArray)(schema.allowUnknownProperties ?? []).map(types_1.valueTypeOrSchemaToSchema))
+    };
+    return normalizedSchema;
+}
+function _normalizeValueSchema(schema) {
+    const normalizedValueSchema = {
+        schema: new Set((0, array_1.toArray)(schema.schema)),
+        array: schema.array ?? false,
+        optional: schema.optional ?? false,
+        nullable: schema.nullable ?? false,
+        coerce: schema.coerce ?? false,
+        coercers: new Map(),
+        transformers: (0, array_1.toArray)(schema.transformers ?? []),
+        arrayConstraints: (0, array_1.toArray)(schema.arrayConstraints ?? []),
+        valueConstraints: (0, array_1.toArray)(schema.valueConstraints ?? [])
+    };
+    for (const coercer of (0, array_1.toArray)(schema.coercers ?? [])) {
+        for (const sourceType of (0, array_1.toArray)(coercer.sourceType)) {
+            if (!normalizedValueSchema.coercers.has(sourceType)) {
+                normalizedValueSchema.coercers.set(sourceType, []);
+            }
+            normalizedValueSchema.coercers.get(sourceType).push(coercer);
+        }
+    }
+    return normalizedValueSchema;
+}
+function _normalizeTypeSchema(schema) {
+    const normalizedSchema = {
+        foo: (0, types_1.resolveValueType)(schema.type)
+    };
+    return normalizedSchema;
+}
+function _getArrayItemSchema(schema) {
+    const itemSchema = {
+        schema: schema.schema,
+        array: false,
+        optional: false,
+        nullable: false,
+        transformers: schema.transformers,
+        valueConstraints: schema.valueConstraints
+    };
+    return itemSchema;
+}
+//# sourceMappingURL=schema.js.map

package/schema/utils/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../source/schema/utils/schema.ts"],"names":[],"mappings":"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"}

package/schema/utils/value-type.d.ts

@@ -0,0 +1,5 @@
+import type { Schema } from '../schema';
+import type { ResolvedValueType, ValueType } from '../types';
+export declare function getValueType(value: unknown): ResolvedValueType<any>;
+export declare function getValueTypeName(valueType: ValueType): string;
+export declare function getSchemaTypeNames(schema: Schema): string[];

package/schema/utils/value-type.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaTypeNames = exports.getValueTypeName = exports.getValueType = void 0;
+const array_1 = require("../../utils/array/array");
+const type_guards_1 = require("../../utils/type-guards");
+const types_1 = require("../types");
+function getValueType(value) {
+    if ((0, type_guards_1.isUndefined)(value)) {
+        return 'undefined';
+    }
+    if ((0, type_guards_1.isNull)(value)) {
+        return 'null';
+    }
+    return value.constructor;
+}
+exports.getValueType = getValueType;
+function getValueTypeName(valueType) {
+    const resolvedValueType = (0, types_1.resolveValueType)(valueType);
+    return (0, type_guards_1.isString)(resolvedValueType)
+        ? resolvedValueType
+        : resolvedValueType.name;
+}
+exports.getValueTypeName = getValueTypeName;
+function getSchemaTypeNames(schema) {
+    if ((0, types_1.isTypeSchema)(schema)) {
+        const name = getValueTypeName(schema.type);
+        return [name];
+    }
+    if ((0, types_1.isObjectSchema)(schema)) {
+        const name = getValueTypeName(schema.sourceType ?? Object);
+        return [name];
+    }
+    if ((0, types_1.isValueSchema)(schema)) {
+        return [...new Set((0, array_1.toArray)(schema.schema).flatMap(getSchemaTypeNames))];
+    }
+    throw new Error('Unsupported schema');
+}
+exports.getSchemaTypeNames = getSchemaTypeNames;
+//# sourceMappingURL=value-type.js.map

package/schema/utils/value-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-type.js","sourceRoot":"","sources":["../../../source/schema/utils/value-type.ts"],"names":[],"mappings":";;;AACA,mDAA8C;AAC9C,yDAAoE;AAGpE,oCAAyF;AAEzF,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,IAAA,yBAAW,EAAC,KAAK,CAAC,EAAE;QACtB,OAAO,WAAW,CAAC;KACpB;IAED,IAAI,IAAA,oBAAM,EAAC,KAAK,CAAC,EAAE;QACjB,OAAO,MAAM,CAAC;KACf;IAED,OAAQ,KAAgB,CAAC,WAAkC,CAAC;AAC9D,CAAC;AAVD,oCAUC;AAED,SAAgB,gBAAgB,CAAC,SAAoB;IACnD,MAAM,iBAAiB,GAAG,IAAA,wBAAgB,EAAC,SAAS,CAAC,CAAC;IAEtD,OAAO,IAAA,sBAAQ,EAAC,iBAAiB,CAAC;QAChC,CAAC,CAAC,iBAAiB;QACnB,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC;AAC7B,CAAC;AAND,4CAMC;AAED,SAAgB,kBAAkB,CAAC,MAAc;IAC/C,IAAI,IAAA,oBAAY,EAAC,MAAM,CAAC,EAAE;QACxB,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC3C,OAAO,CAAC,IAAI,CAAC,CAAC;KACf;IAED,IAAI,IAAA,sBAAc,EAAC,MAAM,CAAC,EAAE;QAC1B,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,CAAC;QAC3D,OAAO,CAAC,IAAI,CAAC,CAAC;KACf;IAED,IAAI,IAAA,qBAAa,EAAC,MAAM,CAAC,EAAE;QACzB,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,IAAA,eAAO,EAAC,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;KACzE;IAED,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;AACxC,CAAC;AAhBD,gDAgBC"}

package/search-index/elastic/config.d.ts

@@ -1,6 +1,6 @@
-import type { Injectable } from "../../container/index.js";
-import { resolveArgumentType } from "../../container/index.js";
-import type { Entity } from "../../database/index.js";
+import type { Injectable } from "../../container";
+import { resolveArgumentType } from "../../container";
+import type { Entity } from "../../database";
 export declare type ElasticSearchIndexConfigArgument<T extends Entity = Entity> = string | ElasticSearchIndexConfig<T>;
 export declare abstract class ElasticSearchIndexConfig<T extends Entity = Entity> implements Injectable<ElasticSearchIndexConfigArgument> {
     readonly indexName: string;

package/search-index/elastic/config.js

@@ -1,3 +1,4 @@
+"use strict";
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -10,17 +11,19 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { injectable, injectArg, resolveArgumentType } from "../../container/index.js";
-import { isString } from "../../utils/type-guards.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElasticSearchIndexConfig = void 0;
+const container_1 = require("../../container");
+const type_guards_1 = require("../../utils/type-guards");
 let ElasticSearchIndexConfig = class ElasticSearchIndexConfig {
     constructor(indexNameOrConfig) {
-        this.indexName = isString(indexNameOrConfig) ? indexNameOrConfig : indexNameOrConfig.indexName;
+        this.indexName = (0, type_guards_1.isString)(indexNameOrConfig) ? indexNameOrConfig : indexNameOrConfig.indexName;
     }
 };
 ElasticSearchIndexConfig = __decorate([
-    injectable(),
-    __param(0, injectArg()),
+    (0, container_1.injectable)(),
+    __param(0, (0, container_1.injectArg)()),
     __metadata("design:paramtypes", [Object])
 ], ElasticSearchIndexConfig);
-export { ElasticSearchIndexConfig };
+exports.ElasticSearchIndexConfig = ElasticSearchIndexConfig;
 //# sourceMappingURL=config.js.map

package/search-index/elastic/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../source/search-index/elastic/config.ts"],"names":[],"mappings":";;;;;;;;;;;;AACA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,mBAAmB,EAAE,iCAA6B;AAElF,OAAO,EAAE,QAAQ,EAAE,mCAA+B;AAKlD,IAAsB,wBAAwB,GAA9C,MAAsB,wBAAwB;IAI5C,YAAyB,iBAAuD;QAC9E,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC;IACjG,CAAC;CACF,CAAA;AAPqB,wBAAwB;IAD7C,UAAU,EAAE;IAKE,WAAA,SAAS,EAAE,CAAA;;GAJJ,wBAAwB,CAO7C;SAPqB,wBAAwB"}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../source/search-index/elastic/config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,+CAAyE;AAEzE,yDAA+C;AAK/C,IAAsB,wBAAwB,GAA9C,MAAsB,wBAAwB;IAI5C,YAAyB,iBAAuD;QAC9E,IAAI,CAAC,SAAS,GAAG,IAAA,sBAAQ,EAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,CAAC,SAAS,CAAC;IACjG,CAAC;CACF,CAAA;AAPqB,wBAAwB;IAD7C,IAAA,sBAAU,GAAE;IAKE,WAAA,IAAA,qBAAS,GAAE,CAAA;;GAJJ,wBAAwB,CAO7C;AAPqB,4DAAwB"}

package/search-index/elastic/index.d.ts

@@ -1,5 +1,6 @@
-export * from './config.js';
-export * from './model/index.js';
-export * from './module.js';
-export * from './search-index.js';
-export * from './types.js';
+export * from './config';
+export * from './keyword-rewriter';
+export * from './model';
+export * from './module';
+export * from './search-index';
+export * from './types';