@mikro-orm/core 7.0.0-dev.9 → 7.0.0-dev.90

package/utils/env-vars.js

@@ -0,0 +1,87 @@
+import { Utils } from './Utils.js';
+/** @internal */
+export function loadEnvironmentVars() {
+    const ret = {};
+    const getEnvKey = (key, envPrefix = 'MIKRO_ORM_') => {
+        return envPrefix + key
+            .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+            .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+            .toUpperCase();
+    };
+    const array = (v) => v.split(',').map(vv => vv.trim());
+    const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
+    const num = (v) => +v;
+    const read = (o, envPrefix, key, mapper = v => v) => {
+        const envKey = getEnvKey(key, envPrefix);
+        if (envKey in process.env) {
+            o[key] = mapper(process.env[envKey]);
+        }
+    };
+    const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
+    const read0 = read.bind(null, ret, 'MIKRO_ORM_');
+    read0('baseDir');
+    read0('entities', array);
+    read0('entitiesTs', array);
+    read0('clientUrl');
+    read0('host');
+    read0('port', num);
+    read0('user');
+    read0('password');
+    read0('dbName');
+    read0('schema');
+    read0('loadStrategy');
+    read0('batchSize', num);
+    read0('useBatchInserts', bool);
+    read0('useBatchUpdates', bool);
+    read0('allowGlobalContext', bool);
+    read0('autoJoinOneToOneOwner', bool);
+    read0('populateAfterFlush', bool);
+    read0('forceEntityConstructor', bool);
+    read0('forceUndefined', bool);
+    read0('forceUtcTimezone', bool);
+    read0('timezone');
+    read0('ensureIndexes', bool);
+    read0('implicitTransactions', bool);
+    read0('debug', bool);
+    read0('colors', bool);
+    ret.discovery = {};
+    const read1 = read.bind(null, ret.discovery, 'MIKRO_ORM_DISCOVERY_');
+    read1('warnWhenNoEntities', bool);
+    read1('checkDuplicateTableNames', bool);
+    read1('checkDuplicateFieldNames', bool);
+    read1('checkDuplicateEntities', bool);
+    read1('checkNonPersistentCompositeProps', bool);
+    read1('inferDefaultValues', bool);
+    read1('tsConfigPath');
+    cleanup(ret, 'discovery');
+    ret.migrations = {};
+    const read2 = read.bind(null, ret.migrations, 'MIKRO_ORM_MIGRATIONS_');
+    read2('tableName');
+    read2('path');
+    read2('pathTs');
+    read2('glob');
+    read2('transactional', bool);
+    read2('disableForeignKeys', bool);
+    read2('allOrNothing', bool);
+    read2('dropTables', bool);
+    read2('safe', bool);
+    read2('silent', bool);
+    read2('emit');
+    read2('snapshot', bool);
+    read2('snapshotName');
+    cleanup(ret, 'migrations');
+    ret.schemaGenerator = {};
+    const read3 = read.bind(null, ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_');
+    read3('disableForeignKeys', bool);
+    read3('createForeignKeyConstraints', bool);
+    cleanup(ret, 'schemaGenerator');
+    ret.seeder = {};
+    const read4 = read.bind(null, ret.seeder, 'MIKRO_ORM_SEEDER_');
+    read4('path');
+    read4('pathTs');
+    read4('glob');
+    read4('emit');
+    read4('defaultSeeder');
+    cleanup(ret, 'seeder');
+    return ret;
+}

package/utils/fs-utils.d.ts

@@ -0,0 +1,12 @@
+import { type Dictionary } from '../typings.js';
+export declare const fs: {
+    pathExists(path: string): boolean;
+    ensureDir(path: string): void;
+    readJSONSync<T = Dictionary>(path: string): T;
+    glob(input: string | string[], cwd?: string): string[];
+    getPackageConfig<T extends Dictionary>(basePath?: string): T;
+    getORMPackages(): Set<string>;
+    getORMPackageVersion(name: string): string | undefined;
+    checkPackageVersion(): void;
+};
+export * from '../cache/FileCacheAdapter.js';

package/utils/fs-utils.js

@@ -0,0 +1,97 @@
+import { existsSync, globSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Utils } from './Utils.js';
+import { colors } from '../logging/colors.js';
+export const fs = {
+    pathExists(path) {
+        if (/[*?[\]]/.test(path)) {
+            return globSync(path).length > 0;
+        }
+        return existsSync(path);
+    },
+    ensureDir(path) {
+        if (!existsSync(path)) {
+            mkdirSync(path, { recursive: true });
+        }
+    },
+    readJSONSync(path) {
+        const file = readFileSync(path);
+        return JSON.parse(file.toString());
+    },
+    glob(input, cwd) {
+        if (Array.isArray(input)) {
+            return input.flatMap(paths => this.glob(paths, cwd));
+        }
+        const hasGlobChars = /[*?[\]]/.test(input);
+        if (!hasGlobChars) {
+            try {
+                const s = statSync(cwd ? Utils.normalizePath(cwd, input) : input);
+                if (s.isDirectory()) {
+                    const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
+                    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const files = globSync(input, { cwd, withFileTypes: true });
+        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+    },
+    getPackageConfig(basePath = process.cwd()) {
+        if (this.pathExists(`${basePath}/package.json`)) {
+            try {
+                const path = import.meta.resolve(`${basePath}/package.json`);
+                return this.readJSONSync(fileURLToPath(path));
+            }
+            catch (e) {
+                /* v8 ignore next */
+                return {};
+            }
+        }
+        const parentFolder = realpathSync(`${basePath}/..`);
+        // we reached the root folder
+        if (basePath === parentFolder) {
+            return {};
+        }
+        return this.getPackageConfig(parentFolder);
+    },
+    getORMPackages() {
+        const pkg = this.getPackageConfig();
+        return new Set([
+            ...Object.keys(pkg.dependencies ?? {}),
+            ...Object.keys(pkg.devDependencies ?? {}),
+        ]);
+    },
+    getORMPackageVersion(name) {
+        try {
+            const path = import.meta.resolve(`${name}/package.json`);
+            const pkg = this.readJSONSync(fileURLToPath(path));
+            return pkg?.version;
+        }
+        catch (e) {
+            return undefined;
+        }
+    },
+    // inspired by https://github.com/facebook/docusaurus/pull/3386
+    checkPackageVersion() {
+        const coreVersion = Utils.getORMVersion();
+        if (process.env.MIKRO_ORM_ALLOW_VERSION_MISMATCH || coreVersion === '[[MIKRO_ORM_VERSION]]') {
+            return;
+        }
+        const deps = this.getORMPackages();
+        const exceptions = new Set(['nestjs', 'sql-highlighter', 'mongo-highlighter']);
+        const ormPackages = [...deps].filter(d => d.startsWith('@mikro-orm/') && d !== '@mikro-orm/core' && !exceptions.has(d.substring('@mikro-orm/'.length)));
+        for (const ormPackage of ormPackages) {
+            const version = this.getORMPackageVersion(ormPackage);
+            if (version != null && version !== coreVersion) {
+                throw new Error(`Bad ${colors.cyan(ormPackage)} version ${colors.yellow('' + version)}.\n` +
+                    `All official @mikro-orm/* packages need to have the exact same version as @mikro-orm/core (${colors.green(coreVersion)}).\n` +
+                    `Only exceptions are packages that don't live in the 'mikro-orm' repository: ${[...exceptions].join(', ')}.\n` +
+                    `Maybe you want to check, or regenerate your yarn.lock or package-lock.json file?`);
+            }
+        }
+    },
+};
+export * from '../cache/FileCacheAdapter.js';

package/utils/index.d.ts

@@ -1,13 +1,14 @@
 export * from './Configuration.js';
-export * from './ConfigurationLoader.js';
 export * from './Cursor.js';
 export * from './DataloaderUtils.js';
 export * from './Utils.js';
 export * from './RequestContext.js';
 export * from './TransactionContext.js';
+export * from './TransactionManager.js';
 export * from './QueryHelper.js';
 export * from './NullHighlighter.js';
 export * from './EntityComparator.js';
 export * from './AbstractSchemaGenerator.js';
 export * from './RawQueryFragment.js';
+export * from './env-vars.js';
 export * from './upsert-utils.js';

package/utils/index.js

@@ -1,13 +1,14 @@
 export * from './Configuration.js';
-export * from './ConfigurationLoader.js';
 export * from './Cursor.js';
 export * from './DataloaderUtils.js';
 export * from './Utils.js';
 export * from './RequestContext.js';
 export * from './TransactionContext.js';
+export * from './TransactionManager.js';
 export * from './QueryHelper.js';
 export * from './NullHighlighter.js';
 export * from './EntityComparator.js';
 export * from './AbstractSchemaGenerator.js';
 export * from './RawQueryFragment.js';
+export * from './env-vars.js';
 export * from './upsert-utils.js';

package/utils/upsert-utils.d.ts

@@ -1,7 +1,12 @@
-import type { EntityData, EntityMetadata } from '../typings.js';
+import type { EntityData, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
-import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { type RawQueryFragment } from '../utils/RawQueryFragment.js';
 /** @internal */
 export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T>): (keyof T)[];
 /** @internal */
 export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T, P>): (keyof T)[] | '*';
+/** @internal */
+export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | RawQueryFragment | undefined, data: EntityData<T>, where: FilterQuery<T>): {
+    where: FilterQuery<T>;
+    propIndex: number | false;
+};

package/utils/upsert-utils.js

@@ -1,9 +1,11 @@
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { Utils } from './Utils.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
     }
     return Object.values(prop.embeddedProps).flatMap(p => {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (p.embeddable && !p.object) {
             return expandEmbeddedProperties(p);
         }
@@ -42,7 +44,7 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
         const onConflictMergeFields = expandFields(meta, options.onConflictMergeFields);
         return onConflictMergeFields.flatMap(f => {
             const prop = meta?.properties[f];
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (prop?.embeddable && !prop.object) {
                 return Object.values(prop.embeddedProps).map(p => p.name);
             }
@@ -67,11 +69,19 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
 }
 /** @internal */
 export function getOnConflictReturningFields(meta, data, uniqueFields, options) {
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     if (!meta) {
         return '*';
     }
-    const keys = meta.comparableProps.filter(p => !p.lazy && !p.embeddable && Array.isArray(uniqueFields) && !uniqueFields.includes(p.name)).map(p => p.name);
+    const keys = meta.comparableProps.filter(p => {
+        if (p.lazy || p.embeddable) {
+            return false;
+        }
+        if (p.autoincrement) {
+            return true;
+        }
+        return Array.isArray(uniqueFields) && !uniqueFields.includes(p.name);
+    }).map(p => p.name);
     if (meta.versionProperty) {
         keys.push(meta.versionProperty);
     }
@@ -88,3 +98,44 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     }
     return keys.filter(key => !(key in data));
 }
+function getPropertyValue(obj, key) {
+    if (key.indexOf('.') === -1) {
+        return obj[key];
+    }
+    const parts = key.split('.');
+    let curr = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        curr[parts[i]] ??= {};
+        curr = curr[parts[i]];
+    }
+    return curr[parts[parts.length - 1]];
+}
+/** @internal */
+export function getWhereCondition(meta, onConflictFields, data, where) {
+    const unique = onConflictFields ?? meta.props.filter(p => p.unique).map(p => p.name);
+    const propIndex = !isRaw(unique) && unique.findIndex(p => data[p] ?? data[p.substring(0, p.indexOf('.'))] != null);
+    if (onConflictFields || where == null) {
+        if (propIndex !== false && propIndex >= 0) {
+            let key = unique[propIndex];
+            if (key.includes('.')) {
+                const prop = meta.properties[key.substring(0, key.indexOf('.'))];
+                if (prop) {
+                    key = `${prop.fieldNames[0]}${key.substring(key.indexOf('.'))}`;
+                }
+            }
+            where = { [key]: getPropertyValue(data, unique[propIndex]) };
+        }
+        else if (meta.uniques.length > 0) {
+            for (const u of meta.uniques) {
+                if (Utils.asArray(u.properties).every(p => data[p] != null)) {
+                    where = Utils.asArray(u.properties).reduce((o, key) => {
+                        o[key] = data[key];
+                        return o;
+                    }, {});
+                    break;
+                }
+            }
+        }
+    }
+    return { where, propIndex };
+}

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,8 +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> {
-    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,18 +0,0 @@
-import type { AnyEntity } from '../typings.js';
-export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (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 {
-    entity?: string | (() => AnyEntity | AnyEntity[]);
-    type?: string;
-    prefix?: string | boolean;
-    prefixMode?: EmbeddedPrefixMode;
-    nullable?: boolean;
-    object?: boolean;
-    array?: boolean;
-    hidden?: boolean;
-    serializer?: (value: any) => any;
-    serializedName?: string;
-    groups?: string[];
-    persist?: 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,18 +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> = {
-    tableName?: string;
-    schema?: string;
-    collection?: string;
-    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
-    discriminatorMap?: Dictionary<string>;
-    discriminatorValue?: number | string;
-    forceConstructor?: boolean;
-    comment?: string;
-    abstract?: boolean;
-    readonly?: boolean;
-    virtual?: boolean;
-    expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>) => object);
-    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 } 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;
-}
-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,40 +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;
-}