@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/cache/NullCacheAdapter.d.ts

@@ -0,0 +1,19 @@
+import type { SyncCacheAdapter } from './CacheAdapter';
+export declare class NullCacheAdapter implements SyncCacheAdapter {
+    /**
+     * @inheritDoc
+     */
+    get(name: string): any;
+    /**
+     * @inheritDoc
+     */
+    set(name: string, data: any, origin: string): void;
+    /**
+     * @inheritDoc
+     */
+    remove(name: string): void;
+    /**
+     * @inheritDoc
+     */
+    clear(): void;
+}

package/cache/NullCacheAdapter.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullCacheAdapter = void 0;
+class NullCacheAdapter {
+    /**
+     * @inheritDoc
+     */
+    get(name) {
+        return null;
+    }
+    /**
+     * @inheritDoc
+     */
+    set(name, data, origin) {
+        // ignore
+    }
+    /**
+     * @inheritDoc
+     */
+    remove(name) {
+        // ignore
+    }
+    /**
+     * @inheritDoc
+     */
+    clear() {
+        // ignore
+    }
+}
+exports.NullCacheAdapter = NullCacheAdapter;

package/cache/index.d.ts

@@ -0,0 +1,5 @@
+export * from './CacheAdapter';
+export * from './NullCacheAdapter';
+export * from './FileCacheAdapter';
+export * from './MemoryCacheAdapter';
+export * from './GeneratedCacheAdapter';

package/cache/index.js

@@ -0,0 +1,21 @@
+"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("./CacheAdapter"), exports);
+__exportStar(require("./NullCacheAdapter"), exports);
+__exportStar(require("./FileCacheAdapter"), exports);
+__exportStar(require("./MemoryCacheAdapter"), exports);
+__exportStar(require("./GeneratedCacheAdapter"), exports);

package/connections/Connection.d.ts

@@ -0,0 +1,85 @@
+import { type Configuration, type ConnectionOptions, type DynamicPassword } from '../utils';
+import type { LogContext, Logger } from '../logging';
+import type { MetadataStorage } from '../metadata';
+import type { ConnectionType, Dictionary, MaybePromise, Primary } from '../typings';
+import type { Platform } from '../platforms/Platform';
+import type { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster';
+import type { IsolationLevel } from '../enums';
+export declare abstract class Connection {
+    protected readonly config: Configuration;
+    protected readonly type: ConnectionType;
+    protected metadata: MetadataStorage;
+    protected platform: Platform;
+    protected readonly options: ConnectionOptions;
+    protected readonly logger: Logger;
+    protected connected: boolean;
+    constructor(config: Configuration, options?: ConnectionOptions, type?: ConnectionType);
+    /**
+     * Establishes connection to database
+     */
+    abstract connect(): void | Promise<void>;
+    /**
+     * Are we connected to the database
+     */
+    abstract isConnected(): Promise<boolean>;
+    /**
+     * Are we connected to the database
+     */
+    abstract checkConnection(): Promise<{
+        ok: boolean;
+        reason?: string;
+        error?: Error;
+    }>;
+    /**
+     * Closes the database connection (aka disconnect)
+     */
+    close(force?: boolean): Promise<void>;
+    /**
+     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     */
+    ensureConnection(): Promise<void>;
+    /**
+     * Returns default client url for given driver (e.g. mongodb://127.0.0.1:27017 for mongodb)
+     */
+    abstract getDefaultClientUrl(): string;
+    transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+        ctx?: Transaction;
+        eventBroadcaster?: TransactionEventBroadcaster;
+    }): Promise<T>;
+    begin(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+        ctx?: Transaction;
+        eventBroadcaster?: TransactionEventBroadcaster;
+    }): Promise<Transaction>;
+    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
+    getConnectionOptions(): ConnectionConfig;
+    getClientUrl(): string;
+    setMetadata(metadata: MetadataStorage): void;
+    setPlatform(platform: Platform): void;
+    getPlatform(): Platform;
+    protected executeQuery<T>(query: string, cb: () => Promise<T>, context?: LogContext): Promise<T>;
+    protected logQuery(query: string, context?: LogContext): void;
+}
+export interface QueryResult<T = {
+    id: number;
+}> {
+    affectedRows: number;
+    insertId: Primary<T>;
+    row?: Dictionary;
+    rows?: Dictionary[];
+    insertedIds?: Primary<T>[];
+}
+export interface ConnectionConfig {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string | (() => MaybePromise<string> | MaybePromise<DynamicPassword>);
+    database?: string;
+    schema?: string;
+}
+export type Transaction<T = any> = T;

package/connections/Connection.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+const url_1 = require("url");
+const utils_1 = require("../utils");
+class Connection {
+    config;
+    type;
+    metadata;
+    platform;
+    options;
+    logger;
+    connected = false;
+    constructor(config, options, type = 'write') {
+        this.config = config;
+        this.type = type;
+        this.logger = this.config.getLogger();
+        if (options) {
+            this.options = options;
+        }
+        else {
+            const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'schema'];
+            this.options = props.reduce((o, i) => {
+                o[i] = this.config.get(i);
+                return o;
+            }, {});
+        }
+    }
+    /**
+     * Closes the database connection (aka disconnect)
+     */
+    async close(force) {
+        Object.keys(this.options)
+            .filter(k => k !== 'name')
+            .forEach(k => delete this.options[k]);
+    }
+    /**
+     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     */
+    async ensureConnection() {
+        if (!this.connected) {
+            await this.connect();
+        }
+    }
+    async transactional(cb, options) {
+        throw new Error(`Transactions are not supported by current driver`);
+    }
+    async begin(options) {
+        throw new Error(`Transactions are not supported by current driver`);
+    }
+    async commit(ctx, eventBroadcaster) {
+        throw new Error(`Transactions are not supported by current driver`);
+    }
+    async rollback(ctx, eventBroadcaster) {
+        throw new Error(`Transactions are not supported by current driver`);
+    }
+    getConnectionOptions() {
+        const ret = {};
+        if (this.options.clientUrl) {
+            const url = new url_1.URL(this.options.clientUrl);
+            this.options.host = ret.host = this.options.host ?? decodeURIComponent(url.hostname);
+            this.options.port = ret.port = this.options.port ?? +url.port;
+            this.options.user = ret.user = this.options.user ?? decodeURIComponent(url.username);
+            this.options.password = ret.password = this.options.password ?? decodeURIComponent(url.password);
+            this.options.dbName = ret.database = this.options.dbName ?? decodeURIComponent(url.pathname).replace(/^\//, '');
+            if (this.options.schema || url.searchParams.has('schema')) {
+                this.options.schema = ret.schema = this.options.schema ?? decodeURIComponent(url.searchParams.get('schema'));
+                this.config.set('schema', ret.schema);
+            }
+        }
+        else {
+            const url = new url_1.URL(this.config.getClientUrl());
+            this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
+            this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
+            this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
+            this.options.password = ret.password = this.options.password ?? this.config.get('password', decodeURIComponent(url.password));
+            this.options.dbName = ret.database = this.options.dbName ?? this.config.get('dbName', decodeURIComponent(url.pathname).replace(/^\//, ''));
+        }
+        return ret;
+    }
+    getClientUrl() {
+        const options = this.getConnectionOptions();
+        const url = new url_1.URL(this.config.getClientUrl(true));
+        const password = options.password ? ':*****' : '';
+        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
+            ? `?schema=${options.schema}`
+            : '';
+        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
+    }
+    setMetadata(metadata) {
+        this.metadata = metadata;
+    }
+    setPlatform(platform) {
+        this.platform = platform;
+    }
+    getPlatform() {
+        return this.platform;
+    }
+    async executeQuery(query, cb, context) {
+        const now = Date.now();
+        try {
+            const res = await cb();
+            this.logQuery(query, {
+                ...context,
+                took: Date.now() - now,
+                results: Array.isArray(res) ? res.length : undefined,
+                affected: utils_1.Utils.isPlainObject(res) ? res.affectedRows : undefined,
+            });
+            return res;
+        }
+        catch (e) {
+            this.logQuery(query, { ...context, took: Date.now() - now, level: 'error' });
+            throw e;
+        }
+    }
+    logQuery(query, context = {}) {
+        this.logger.logQuery({
+            level: 'info',
+            connection: {
+                type: this.type,
+                name: this.options.name || this.config.get('name') || this.options.host,
+            },
+            ...context,
+            query,
+        });
+    }
+}
+exports.Connection = Connection;

package/connections/index.d.ts

@@ -0,0 +1 @@
+export * from './Connection';

package/connections/index.js

@@ -0,0 +1,17 @@
+"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("./Connection"), exports);

package/decorators/Check.d.ts

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

package/decorators/Check.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Check = void 0;
+const metadata_1 = require("../metadata");
+const Utils_1 = require("../utils/Utils");
+function Check(options) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator((propertyName ? target.constructor : target));
+        options.property ??= propertyName;
+        meta.checks.push(options);
+        if (!propertyName) {
+            return target;
+        }
+        return Utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.Check = Check;

package/decorators/CreateRequestContext.d.ts

@@ -0,0 +1,2 @@
+import { MikroORM } from '../MikroORM';
+export declare function CreateRequestContext<T>(getContext?: MikroORM | Promise<MikroORM> | ((type?: T) => MikroORM | Promise<MikroORM>)): MethodDecorator;

package/decorators/CreateRequestContext.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRequestContext = void 0;
+const MikroORM_1 = require("../MikroORM");
+const RequestContext_1 = require("../utils/RequestContext");
+function CreateRequestContext(getContext) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            /* istanbul ignore next */
+            let orm;
+            if (typeof getContext === 'function') {
+                orm = await (getContext(this) ?? this.orm);
+            }
+            else if (getContext) {
+                orm = await getContext;
+            }
+            else {
+                orm = await this.orm;
+            }
+            if (!(orm instanceof MikroORM_1.MikroORM)) {
+                throw new Error('@CreateRequestContext() decorator can only be applied to methods of classes with `orm: MikroORM` property, or with a callback parameter like `@CreateRequestContext(() => orm)`');
+            }
+            return await RequestContext_1.RequestContext.create(orm.em, () => {
+                return originalMethod.apply(this, args);
+            });
+        };
+        return descriptor;
+    };
+}
+exports.CreateRequestContext = CreateRequestContext;

package/decorators/Embeddable.d.ts

@@ -0,0 +1,8 @@
+import type { Dictionary } from '../typings';
+export declare function Embeddable(options?: EmbeddableOptions): <T>(target: T & Dictionary) => T & Dictionary;
+export type EmbeddableOptions = {
+    discriminatorColumn?: string;
+    discriminatorMap?: Dictionary<string>;
+    discriminatorValue?: number | string;
+    abstract?: boolean;
+};

package/decorators/Embeddable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embeddable = void 0;
+const metadata_1 = require("../metadata");
+function Embeddable(options = {}) {
+    return function (target) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target);
+        meta.class = target;
+        meta.name = target.name;
+        meta.embeddable = true;
+        Object.assign(meta, options);
+        return target;
+    };
+}
+exports.Embeddable = Embeddable;

package/decorators/Embedded.d.ts

@@ -0,0 +1,13 @@
+import type { AnyEntity } from '../typings';
+export declare function Embedded<T extends object>(type?: EmbeddedOptions | (() => AnyEntity), options?: EmbeddedOptions): (target: AnyEntity, propertyName: string) => any;
+export type EmbeddedOptions = {
+    entity?: string | (() => AnyEntity | AnyEntity[]);
+    type?: string;
+    prefix?: string | boolean;
+    nullable?: boolean;
+    object?: boolean;
+    array?: boolean;
+    hidden?: boolean;
+    serializer?: (value: any) => any;
+    serializedName?: string;
+};

package/decorators/Embedded.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embedded = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+function Embedded(type = {}, options = {}) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.EMBEDDED);
+        options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
+        utils_1.Utils.defaultValue(options, 'prefix', true);
+        meta.properties[propertyName] = {
+            name: propertyName,
+            kind: enums_1.ReferenceKind.EMBEDDED,
+            ...options,
+        };
+        return utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.Embedded = Embedded;

package/decorators/EnsureRequestContext.d.ts

@@ -0,0 +1,2 @@
+import { MikroORM } from '../MikroORM';
+export declare function EnsureRequestContext<T>(getContext?: MikroORM | ((type?: T) => MikroORM)): MethodDecorator;

package/decorators/EnsureRequestContext.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnsureRequestContext = void 0;
+const MikroORM_1 = require("../MikroORM");
+const RequestContext_1 = require("../utils/RequestContext");
+function EnsureRequestContext(getContext) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            // reuse existing context if available
+            if (RequestContext_1.RequestContext.currentRequestContext()) {
+                return originalMethod.apply(this, args);
+            }
+            /* istanbul ignore next */
+            const orm = getContext instanceof MikroORM_1.MikroORM ? getContext : (getContext?.(this) ?? this.orm);
+            if (!(orm instanceof MikroORM_1.MikroORM)) {
+                throw new Error('@EnsureRequestContext() decorator can only be applied to methods of classes with `orm: MikroORM` property, or with a callback parameter like `@EnsureRequestContext(() => orm)`');
+            }
+            return await RequestContext_1.RequestContext.create(orm.em, () => {
+                return originalMethod.apply(this, args);
+            });
+        };
+        return descriptor;
+    };
+}
+exports.EnsureRequestContext = EnsureRequestContext;

package/decorators/Entity.d.ts

@@ -0,0 +1,18 @@
+import type { Constructor, Dictionary, FilterQuery } from '../typings';
+import type { FindOptions } from '../drivers/IDatabaseDriver';
+export declare function Entity(options?: EntityOptions<any>): <T>(target: T & Dictionary) => T & Dictionary;
+export type EntityOptions<T> = {
+    tableName?: string;
+    schema?: string;
+    collection?: string;
+    discriminatorColumn?: string;
+    discriminatorMap?: Dictionary<string>;
+    discriminatorValue?: number | string;
+    forceConstructor?: boolean;
+    comment?: string;
+    abstract?: boolean;
+    readonly?: boolean;
+    virtual?: boolean;
+    expression?: string | ((em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => object);
+    repository?: () => Constructor;
+};

package/decorators/Entity.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+function Entity(options = {}) {
+    return function (target) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target);
+        utils_1.Utils.mergeConfig(meta, options);
+        meta.class = target;
+        if (!options.abstract || meta.discriminatorColumn) {
+            meta.name = target.name;
+        }
+        return target;
+    };
+}
+exports.Entity = Entity;

package/decorators/Enum.d.ts

@@ -0,0 +1,9 @@
+import type { PropertyOptions } from './Property';
+import type { AnyEntity, Dictionary } from '../typings';
+export declare function Enum<T extends object>(options?: EnumOptions<AnyEntity> | (() => Dictionary)): (target: AnyEntity, 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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = void 0;
+const metadata_1 = require("../metadata");
+const enums_1 = require("../enums");
+const Utils_1 = require("../utils/Utils");
+function Enum(options = {}) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        options = options instanceof Function ? { items: options } : options;
+        meta.properties[propertyName] = {
+            name: propertyName,
+            kind: enums_1.ReferenceKind.SCALAR,
+            enum: true,
+            ...options,
+        };
+        return Utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.Enum = Enum;

package/decorators/Filter.d.ts

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

package/decorators/Filter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filter = void 0;
+const metadata_1 = require("../metadata");
+function Filter(options) {
+    return function (target) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target);
+        meta.filters[options.name] = options;
+        return target;
+    };
+}
+exports.Filter = Filter;

package/decorators/Formula.d.ts

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

package/decorators/Formula.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Formula = void 0;
+const metadata_1 = require("../metadata");
+const enums_1 = require("../enums");
+const Utils_1 = require("../utils/Utils");
+function Formula(formula, options = {}) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        meta.properties[propertyName] = {
+            name: propertyName,
+            kind: enums_1.ReferenceKind.SCALAR,
+            formula,
+            ...options,
+        };
+        return Utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.Formula = Formula;

package/decorators/Indexed.d.ts

@@ -0,0 +1,12 @@
+import type { Dictionary } from '../typings';
+export declare function Index<T>(options?: IndexOptions<T>): (target: Partial<any>, propertyName?: string | undefined) => any;
+export declare function Unique<T>(options?: UniqueOptions<T>): (target: Partial<any>, propertyName?: string | undefined) => any;
+export interface UniqueOptions<T> {
+    name?: string;
+    properties?: keyof T | (keyof T)[];
+    options?: Dictionary;
+    expression?: string;
+}
+export interface IndexOptions<T> extends UniqueOptions<T> {
+    type?: string;
+}

package/decorators/Indexed.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unique = exports.Index = void 0;
+const metadata_1 = require("../metadata");
+const Utils_1 = require("../utils/Utils");
+function createDecorator(options, unique) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
+        options.properties = options.properties || propertyName;
+        const key = unique ? 'uniques' : 'indexes';
+        meta[key].push(options);
+        if (!propertyName) {
+            return target;
+        }
+        return Utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+function Index(options = {}) {
+    return createDecorator(options, false);
+}
+exports.Index = Index;
+function Unique(options = {}) {
+    return createDecorator(options, true);
+}
+exports.Unique = Unique;

package/decorators/ManyToMany.d.ts

@@ -0,0 +1,21 @@
+import type { ReferenceOptions } from './Property';
+import type { EntityName, AnyEntity, FilterQuery } from '../typings';
+import { type QueryOrderMap } from '../enums';
+export declare function ManyToMany<T extends object, O>(entity?: ManyToManyOptions<T, O> | string | (() => EntityName<T>), mappedBy?: (string & keyof T) | ((e: T) => any), options?: Partial<ManyToManyOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+    owner?: boolean;
+    inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    mappedBy?: (string & keyof Target) | ((e: Target) => any);
+    where?: FilterQuery<Target>;
+    orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
+    fixedOrder?: boolean;
+    fixedOrderColumn?: string;
+    pivotTable?: string;
+    pivotEntity?: string | (() => EntityName<any>);
+    joinColumn?: string;
+    joinColumns?: string[];
+    inverseJoinColumn?: string;
+    inverseJoinColumns?: string[];
+    referenceColumnName?: string;
+    referencedColumnNames?: string[];
+}