@mikro-orm/core 7.0.0-dev.62 → 7.0.0-dev.64

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.62",
+  "version": "7.0.0-dev.64",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -52,8 +52,7 @@
     "access": "public"
   },
   "dependencies": {
-    "mikro-orm": "7.0.0-dev.62",
-    "reflect-metadata": "0.2.2"
+    "mikro-orm": "7.0.0-dev.64"
   },
   "peerDependencies": {
     "dataloader": "2.2.3"

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Transaction } from './connections/Connection.js';
-import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums.js';
+import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind, type EmbeddedPrefixMode } from './enums.js';
 import { type AssignOptions } from './entity/EntityAssigner.js';
 import { type EntityIdentifier } from './entity/EntityIdentifier.js';
 import { type EntityLoaderOptions } from './entity/EntityLoader.js';
@@ -7,7 +7,6 @@ import { type Collection } from './entity/Collection.js';
 import { type EntityFactory } from './entity/EntityFactory.js';
 import { type EntityRepository } from './entity/EntityRepository.js';
 import { Reference, type ScalarReference } from './entity/Reference.js';
-import type { MikroORM } from './MikroORM.js';
 import type { SerializationContext } from './serialization/SerializationContext.js';
 import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
@@ -17,7 +16,6 @@ import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
 import type { RawQueryFragment } from './utils/RawQueryFragment.js';
 import type { EntityManager } from './EntityManager.js';
-import type { EmbeddedPrefixMode } from './decorators/Embedded.js';
 import type { EventSubscriber } from './events/EventSubscriber.js';
 import type { FilterOptions, FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
 export type Constructor<T = unknown> = new (...args: any[]) => T;
@@ -150,7 +148,6 @@ export type FilterValue<T> = OperatorMap<FilterItemValue<T>> | FilterItemValue<T
 export type FilterObject<T> = {
     -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null;
 };
-export type ExpandObject<T> = T extends object ? T extends Scalar ? never : FilterObject<T> : never;
 export type ExpandQuery<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
 export type EntityProps<T> = {
     -readonly [K in EntityKey<T>]?: T[K];
@@ -583,6 +580,7 @@ export interface GenerateOptions {
     bidirectionalRelations?: boolean;
     identifiedReferences?: boolean;
     entityDefinition?: 'decorators' | 'defineEntity' | 'entitySchema';
+    decorators?: 'es' | 'legacy';
     inferEntityType?: boolean;
     enumMode?: 'ts-enum' | 'union-type' | 'dictionary';
     esmImport?: boolean;
@@ -847,12 +845,6 @@ export interface Seeder<T extends Dictionary = Dictionary> {
 }
 export type ConnectionType = 'read' | 'write';
 export type MetadataProcessor = (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>;
-/**
- * The type of context that the user intends to inject.
- */
-export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-}>);
 export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
 export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>> extends EntitySchema<TEntity, TBase> {
     readonly name: TName;

package/utils/Configuration.d.ts

@@ -9,15 +9,13 @@ import { type Logger, type LoggerNamespace, type LoggerOptions } from '../loggin
 import type { EntityManager } from '../EntityManager.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntitySchema } from '../metadata/EntitySchema.js';
-import type { MetadataProvider } from '../metadata/MetadataProvider.js';
+import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { ReflectMetadataProvider } from '../metadata/ReflectMetadataProvider.js';
-import type { EmbeddedPrefixMode } from '../decorators/Embedded.js';
 import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { AssignOptions } from '../entity/EntityAssigner.js';
 import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import { NotFoundError } from '../errors.js';
-import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
+import { DataloaderType, FlushMode, LoadStrategy, PopulateHint, type EmbeddedPrefixMode } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
 import type { Type } from '../types/Type.js';
@@ -31,13 +29,10 @@ declare const DEFAULTS: {
     readonly filters: {};
     readonly discovery: {
         readonly warnWhenNoEntities: true;
-        readonly requireEntitiesArray: false;
         readonly checkDuplicateTableNames: true;
         readonly checkDuplicateFieldNames: true;
         readonly checkDuplicateEntities: true;
         readonly checkNonPersistentCompositeProps: true;
-        readonly alwaysAnalyseProperties: true;
-        readonly disableDynamicFileAccess: false;
         readonly inferDefaultValues: true;
     };
     readonly strict: false;
@@ -118,6 +113,7 @@ declare const DEFAULTS: {
         readonly identifiedReferences: true;
         readonly scalarPropertiesForRelations: "never";
         readonly entityDefinition: "defineEntity";
+        readonly decorators: "legacy";
         readonly enumMode: "dictionary";
         readonly fileName: (className: string) => string;
         readonly onlyPurePivotTables: false;
@@ -137,7 +133,7 @@ declare const DEFAULTS: {
         readonly expiration: 1000;
         readonly options: {};
     };
-    readonly metadataProvider: typeof ReflectMetadataProvider;
+    readonly metadataProvider: typeof MetadataProvider;
     readonly highlighter: NullHighlighter;
     readonly seeder: {
         readonly path: "./seeders";
@@ -284,18 +280,16 @@ export interface PoolConfig {
 }
 export interface MetadataDiscoveryOptions {
     warnWhenNoEntities?: boolean;
-    requireEntitiesArray?: boolean;
     checkDuplicateTableNames?: boolean;
     checkDuplicateFieldNames?: boolean;
     checkDuplicateEntities?: boolean;
     checkNonPersistentCompositeProps?: boolean;
-    alwaysAnalyseProperties?: boolean;
-    disableDynamicFileAccess?: boolean;
     inferDefaultValues?: boolean;
     getMappedType?: (type: string, platform: Platform) => Type<unknown> | undefined;
     onMetadata?: (meta: EntityMetadata, platform: Platform) => MaybePromise<void>;
     afterDiscovered?: (storage: MetadataStorage, platform: Platform) => MaybePromise<void>;
     tsConfigPath?: string;
+    /** @internal */
     skipSyncDiscovery?: boolean;
 }
 export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {

package/utils/Configuration.js

@@ -5,7 +5,7 @@ import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { DefaultLogger } from '../logging/DefaultLogger.js';
 import { colors } from '../logging/colors.js';
 import { Utils } from '../utils/Utils.js';
-import { ReflectMetadataProvider } from '../metadata/ReflectMetadataProvider.js';
+import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import { NotFoundError } from '../errors.js';
 import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
@@ -20,13 +20,10 @@ const DEFAULTS = {
     filters: {},
     discovery: {
         warnWhenNoEntities: true,
-        requireEntitiesArray: false,
         checkDuplicateTableNames: true,
         checkDuplicateFieldNames: true,
         checkDuplicateEntities: true,
         checkNonPersistentCompositeProps: true,
-        alwaysAnalyseProperties: true,
-        disableDynamicFileAccess: false,
         inferDefaultValues: true,
     },
     strict: false,
@@ -108,6 +105,7 @@ const DEFAULTS = {
         identifiedReferences: true,
         scalarPropertiesForRelations: 'never',
         entityDefinition: 'defineEntity',
+        decorators: 'legacy',
         enumMode: 'dictionary',
         fileName: (className) => className,
         onlyPurePivotTables: false,
@@ -125,7 +123,7 @@ const DEFAULTS = {
         expiration: 1000, // 1s
         options: {},
     },
-    metadataProvider: ReflectMetadataProvider,
+    metadataProvider: MetadataProvider,
     highlighter: new NullHighlighter(),
     seeder: {
         path: './seeders',

package/utils/ConfigurationLoader.js

@@ -245,9 +245,12 @@ export class ConfigurationLoader {
         read(ret, 'MIKRO_ORM_COLORS', 'colors', bool);
         ret.discovery = {};
         read(ret.discovery, 'MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES', 'warnWhenNoEntities', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY', 'requireEntitiesArray', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES', 'alwaysAnalyseProperties', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS', 'disableDynamicFileAccess', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_TABLE_NAMES', 'checkDuplicateTableNames', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_FIELD_NAMES', 'checkDuplicateFieldNames', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_ENTITIES', 'checkDuplicateEntities', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_NON_PERSISTENT_COMPOSITE_PROPS', 'checkNonPersistentCompositeProps', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_INFER_DEFAULT_VALUES', 'inferDefaultValues', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_TS_CONFIG_PATH', 'tsConfigPath');
         cleanup(ret, 'discovery');
         ret.migrations = {};
         read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TABLE_NAME', 'tableName');

package/utils/Utils.d.ts

@@ -227,10 +227,6 @@ export declare class Utils {
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue(): any;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
     static tryRequire<T extends Dictionary = any>({ module, from, allowError, warning }: {

package/utils/Utils.js

@@ -975,14 +975,6 @@ export class Utils {
             throw e;
         }
     }
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue() {
-        if (process.env.BABEL_DECORATORS_COMPAT) {
-            return {};
-        }
-    }
     static unwrapProperty(entity, meta, prop, payload = false) {
         let p = prop;
         const path = [];

package/decorators/Check.d.ts

@@ -1,3 +0,0 @@
-import type { CheckConstraint, EntityClass } from '../typings.js';
-export declare function Check<T>(options: CheckOptions<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
-export type CheckOptions<T = any> = CheckConstraint<T>;

package/decorators/Check.js

@@ -1,13 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-export function Check(options) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator((propertyName ? target.constructor : target));
-        options.property ??= propertyName;
-        meta.checks.push(options);
-        if (!propertyName) {
-            return target;
-        }
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/CreateRequestContext.d.ts

@@ -1,3 +0,0 @@
-import type { ContextProvider } from '../typings.js';
-export declare function CreateRequestContext<T extends object>(context?: ContextProvider<T>, respectExistingContext?: boolean): MethodDecorator;
-export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): MethodDecorator;

package/decorators/CreateRequestContext.js

@@ -1,32 +0,0 @@
-import { RequestContext } from '../utils/RequestContext.js';
-import { resolveContextProvider } from '../utils/resolveContextProvider.js';
-import { TransactionContext } from '../utils/TransactionContext.js';
-export function CreateRequestContext(context, respectExistingContext = false) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
-        if (originalMethod.constructor.name !== 'AsyncFunction') {
-            throw new Error(`@${name}() should be use with async functions`);
-        }
-        descriptor.value = async function (...args) {
-            const em = await resolveContextProvider(this, context);
-            if (!em) {
-                throw new Error(`@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
-            }
-            // reuse existing context if available for given respect `contextName`
-            if (respectExistingContext && RequestContext.getEntityManager(em.name)) {
-                return originalMethod.apply(this, args);
-            }
-            // Otherwise, the outer tx context would be preferred.
-            const txContext = TransactionContext.currentTransactionContext();
-            const provider = txContext ? TransactionContext : RequestContext;
-            return txContext
-                ? provider.create(em.fork({ useContext: true }), () => originalMethod.apply(this, args))
-                : provider.create(em, () => originalMethod.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-export function EnsureRequestContext(context) {
-    return CreateRequestContext(context, true);
-}

package/decorators/Embeddable.d.ts

@@ -1,10 +0,0 @@
-import type { AnyString, Dictionary, EntityClass } from '../typings.js';
-export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
-export interface EmbeddableOptions<T> {
-    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
-    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
-    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
-    discriminatorMap?: Dictionary<string>;
-    discriminatorValue?: number | string;
-    abstract?: boolean;
-}

package/decorators/Embeddable.js

@@ -1,11 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-export function Embeddable(options = {}) {
-    return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
-        meta.class = target;
-        meta.name = meta.class.name;
-        meta.embeddable = true;
-        Object.assign(meta, options);
-        return target;
-    };
-}

package/decorators/Embedded.d.ts

@@ -1,12 +0,0 @@
-import type { AnyEntity, EntityName } from '../typings.js';
-import type { PropertyOptions } from './Property.js';
-export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName<Target>[]), options?: EmbeddedOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => any;
-/** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
-export type EmbeddedPrefixMode = 'absolute' | 'relative';
-export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
-    entity?: string | (() => EntityName<Target> | EntityName<Target>[]);
-    prefix?: string | boolean;
-    prefixMode?: EmbeddedPrefixMode;
-    object?: boolean;
-    array?: boolean;
-}

package/decorators/Embedded.js

@@ -1,18 +0,0 @@
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function Embedded(type = {}, options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
-        options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
-        Utils.defaultValue(options, 'prefix', true);
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.EMBEDDED,
-            ...options,
-        };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/Entity.d.ts

@@ -1,35 +0,0 @@
-import type { AnyString, Constructor, Dictionary, EntityClass, ObjectQuery } from '../typings.js';
-import type { FindOptions } from '../drivers/IDatabaseDriver.js';
-export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
-export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
-    /** Override default collection/table name. Alias for `collection`. */
-    tableName?: string;
-    /** Sets the schema name. */
-    schema?: string;
-    /** Override default collection/table name. Alias for `tableName`. */
-    collection?: string;
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorMap?: Dictionary<string>;
-    /** For {@doclink inheritance-mapping#single-table-inheritance | Single Table Inheritance}. */
-    discriminatorValue?: number | string;
-    /**	Enforce use of constructor when creating managed entity instances. */
-    forceConstructor?: boolean;
-    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
-    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
-    /** Specify comment to table. (SQL only) */
-    comment?: string;
-    /**	Marks entity as abstract, such entities are inlined during discovery. */
-    abstract?: boolean;
-    /** Disables change tracking - such entities are ignored during flush. */
-    readonly?: boolean;
-    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
-    virtual?: boolean;
-    /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
-    hasTriggers?: boolean;
-    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
-    expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>, stream?: boolean) => object);
-    /** Set {@doclink repositories#custom-repository | custom repository class}. */
-    repository?: () => Constructor;
-};

package/decorators/Entity.js

@@ -1,12 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-export function Entity(options = {}) {
-    return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
-        Utils.mergeConfig(meta, options);
-        meta.class = target;
-        if (!options.abstract || meta.discriminatorColumn) {
-            meta.name = target.name;
-        }
-    };
-}

package/decorators/Enum.d.ts

@@ -1,9 +0,0 @@
-import type { PropertyOptions } from './Property.js';
-import type { AnyEntity, Dictionary } from '../typings.js';
-export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: T, propertyName: string) => any;
-export interface EnumOptions<T> extends PropertyOptions<T> {
-    items?: (number | string)[] | (() => Dictionary);
-    array?: boolean;
-    /** for postgres, by default it uses text column with check constraint */
-    nativeEnumName?: string;
-}

package/decorators/Enum.js

@@ -1,16 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-export function Enum(options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        options = options instanceof Function ? { items: options } : options;
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            enum: true,
-            ...options,
-        };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/Filter.d.ts

@@ -1,2 +0,0 @@
-import type { Dictionary, FilterDef } from '../typings.js';
-export declare function Filter<T>(options: FilterDef): <U>(target: U & Dictionary) => U & Dictionary;

package/decorators/Filter.js

@@ -1,8 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-export function Filter(options) {
-    return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
-        meta.filters[options.name] = options;
-        return target;
-    };
-}

package/decorators/Formula.d.ts

@@ -1,4 +0,0 @@
-import type { PropertyOptions } from './Property.js';
-export declare function Formula<T extends object>(formula: string | ((alias: string) => string), options?: FormulaOptions<T>): (target: T, propertyName: string) => any;
-export interface FormulaOptions<T> extends PropertyOptions<T> {
-}

package/decorators/Formula.js

@@ -1,15 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-export function Formula(formula, options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.SCALAR,
-            formula,
-            ...options,
-        };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/Indexed.d.ts

@@ -1,19 +0,0 @@
-import type { EntityClass, Dictionary, AutoPath, IndexCallback } from '../typings.js';
-import type { DeferMode } from '../enums.js';
-export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
-export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
-type MaybeArray<T> = T | T[];
-type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
-interface BaseOptions<T, H extends string> {
-    name?: string;
-    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
-    options?: Dictionary;
-    expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
-}
-export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
-    deferMode?: DeferMode | `${DeferMode}`;
-}
-export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
-    type?: string;
-}
-export {};

package/decorators/Indexed.js

@@ -1,20 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-function createDecorator(options, unique) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties ??= propertyName;
-        const key = unique ? 'uniques' : 'indexes';
-        meta[key].push(options);
-        if (!propertyName) {
-            return target;
-        }
-        return Utils.propertyDecoratorReturnValue();
-    };
-}
-export function Index(options = {}) {
-    return createDecorator(options, false);
-}
-export function Unique(options = {}) {
-    return createDecorator(options, true);
-}

package/decorators/ManyToMany.d.ts

@@ -1,42 +0,0 @@
-import type { ReferenceOptions } from './Property.js';
-import type { EntityName, FilterQuery, AnyString } from '../typings.js';
-import { type QueryOrderMap } from '../enums.js';
-export declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | string | (() => EntityName<Target>), mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
-export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
-    /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
-    owner?: boolean;
-    /** Point to the inverse side property name. */
-    inversedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Point to the owning side property name. */
-    mappedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
-    where?: FilterQuery<Target>;
-    /** Set default ordering. */
-    orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
-    /** Force stable insertion order of items in the collection (see {@doclink collections | Collections}). */
-    fixedOrder?: boolean;
-    /** Override default order column name (`id`) for fixed ordering. */
-    fixedOrderColumn?: string;
-    /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
-    pivotTable?: string;
-    /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
-    pivotEntity?: string | (() => EntityName<any>);
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    joinColumn?: string;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    joinColumns?: string[];
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    inverseJoinColumn?: string;
-    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    inverseJoinColumns?: string[];
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName?: string;
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames?: string[];
-    /** What to do when the target entity gets deleted. */
-    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** Enable/disable foreign key constraint creation on this relation */
-    createForeignKeyConstraint?: boolean;
-}

package/decorators/ManyToMany.js

@@ -1,14 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function ManyToMany(entity, mappedBy, options = {}) {
-    return function (target, propertyName) {
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_MANY);
-        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_MANY };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/ManyToOne.d.ts

@@ -1,34 +0,0 @@
-import type { ReferenceOptions } from './Property.js';
-import { type DeferMode } from '../enums.js';
-import type { AnyString, EntityName } from '../typings.js';
-export declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: keyof Owner) => any;
-export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
-    /** Point to the inverse side property name. */
-    inversedBy?: (string & keyof Target) | ((e: Target) => any);
-    /** Wrap the entity in {@apilink Reference} wrapper. */
-    ref?: boolean;
-    /** Use this relation as a primary key. */
-    primary?: boolean;
-    /** Map this relation to the primary key value instead of an entity. */
-    mapToPk?: boolean;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    joinColumn?: string;
-    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    joinColumns?: string[];
-    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
-    ownColumns?: string[];
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
-    referenceColumnName?: string;
-    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
-    referencedColumnNames?: string[];
-    /** What to do when the target entity gets deleted. */
-    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
-    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
-    deferMode?: DeferMode | `${DeferMode}`;
-    /** Enable/disable foreign key constraint creation on this relation */
-    createForeignKeyConstraint?: boolean;
-    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
-    foreignKeyName?: string;
-}

package/decorators/ManyToOne.js

@@ -1,14 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function ManyToOne(entity = {}, options = {}) {
-    return function (target, propertyName) {
-        options = Utils.processDecoratorParameters({ entity, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.MANY_TO_ONE);
-        const property = { name: propertyName, kind: ReferenceKind.MANY_TO_ONE };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return Utils.propertyDecoratorReturnValue();
-    };
-}