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

package/decorators/ManyToMany.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToMany = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+function ManyToMany(entity, mappedBy, options = {}) {
+    return function (target, propertyName) {
+        options = utils_1.Utils.processDecoratorParameters({ entity, mappedBy, options });
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.MANY_TO_MANY);
+        const property = { name: propertyName, kind: enums_1.ReferenceKind.MANY_TO_MANY };
+        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+        return utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.ManyToMany = ManyToMany;

package/decorators/ManyToOne.d.ts

@@ -0,0 +1,15 @@
+import type { ReferenceOptions } from './Property';
+import type { AnyEntity, AnyString, EntityName } from '../typings';
+export declare function ManyToOne<T extends object, O>(entity?: ManyToOneOptions<T, O> | string | ((e?: any) => EntityName<T>), options?: Partial<ManyToOneOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
+export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+    inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    ref?: boolean;
+    primary?: boolean;
+    mapToPk?: boolean;
+    joinColumn?: string;
+    joinColumns?: string[];
+    referenceColumnName?: string;
+    referencedColumnNames?: string[];
+    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+}

package/decorators/ManyToOne.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToOne = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+function ManyToOne(entity = {}, options = {}) {
+    return function (target, propertyName) {
+        options = utils_1.Utils.processDecoratorParameters({ entity, options });
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.MANY_TO_ONE);
+        const property = { name: propertyName, kind: enums_1.ReferenceKind.MANY_TO_ONE };
+        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+        return utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.ManyToOne = ManyToOne;

package/decorators/OneToMany.d.ts

@@ -0,0 +1,18 @@
+import type { ReferenceOptions } from './Property';
+import { ReferenceKind, type QueryOrderMap } from '../enums';
+import type { EntityName, AnyEntity, FilterQuery } from '../typings';
+export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: AnyEntity, propertyName: string) => any;
+export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: AnyEntity, propertyName: string) => void;
+export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
+export type OneToManyOptions<Owner, Target> = ReferenceOptions<Owner, Target> & {
+    entity?: string | (() => EntityName<Target>);
+    orphanRemoval?: boolean;
+    orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
+    where?: FilterQuery<Target>;
+    joinColumn?: string;
+    joinColumns?: string[];
+    inverseJoinColumn?: string;
+    inverseJoinColumns?: string[];
+    referenceColumnName?: string;
+    mappedBy: (string & keyof Target) | ((e: Target) => any);
+};

package/decorators/OneToMany.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneToMany = exports.createOneToDecorator = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+function createOneToDecorator(entity, mappedBy, options, kind) {
+    return function (target, propertyName) {
+        options = utils_1.Utils.processDecoratorParameters({ entity, mappedBy, options });
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, kind);
+        const property = { name: propertyName, kind };
+        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
+        return utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.createOneToDecorator = createOneToDecorator;
+function OneToMany(entity, mappedBy, options = {}) {
+    return createOneToDecorator(entity, mappedBy, options, enums_1.ReferenceKind.ONE_TO_MANY);
+}
+exports.OneToMany = OneToMany;

package/decorators/OneToOne.d.ts

@@ -0,0 +1,12 @@
+import { type OneToManyOptions } from './OneToMany';
+import type { AnyString, EntityName } from '../typings';
+export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Partial<any>, propertyName: string) => any;
+export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
+    owner?: boolean;
+    inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    ref?: boolean;
+    primary?: boolean;
+    mapToPk?: boolean;
+    deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+}

package/decorators/OneToOne.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneToOne = void 0;
+const enums_1 = require("../enums");
+const OneToMany_1 = require("./OneToMany");
+function OneToOne(entity, mappedByOrOptions, options = {}) {
+    const mappedBy = typeof mappedByOrOptions === 'object' ? mappedByOrOptions.mappedBy : mappedByOrOptions;
+    options = typeof mappedByOrOptions === 'object' ? { ...mappedByOrOptions, ...options } : options;
+    return (0, OneToMany_1.createOneToDecorator)(entity, mappedBy, options, enums_1.ReferenceKind.ONE_TO_ONE);
+}
+exports.OneToOne = OneToOne;

package/decorators/PrimaryKey.d.ts

@@ -0,0 +1,8 @@
+import type { PropertyOptions } from './Property';
+export declare function PrimaryKey<T extends object>(options?: PrimaryKeyOptions<T>): (target: Partial<any>, propertyName: string) => any;
+export declare function SerializedPrimaryKey<T extends object>(options?: SerializedPrimaryKeyOptions<T>): (target: Partial<any>, propertyName: string) => any;
+export interface PrimaryKeyOptions<T> extends PropertyOptions<T> {
+}
+export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {
+    type?: any;
+}

package/decorators/PrimaryKey.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializedPrimaryKey = exports.PrimaryKey = void 0;
+const metadata_1 = require("../metadata");
+const enums_1 = require("../enums");
+const Utils_1 = require("../utils/Utils");
+function createDecorator(options, serialized) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.SCALAR);
+        const k = serialized ? 'serializedPrimaryKey' : 'primary';
+        options[k] = true;
+        meta.properties[propertyName] = { name: propertyName, kind: enums_1.ReferenceKind.SCALAR, ...options };
+        return Utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+function PrimaryKey(options = {}) {
+    return createDecorator(options, false);
+}
+exports.PrimaryKey = PrimaryKey;
+function SerializedPrimaryKey(options = {}) {
+    return createDecorator(options, true);
+}
+exports.SerializedPrimaryKey = SerializedPrimaryKey;

package/decorators/Property.d.ts

@@ -0,0 +1,218 @@
+import { type Cascade, type LoadStrategy } from '../enums';
+import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, AnyString, AnyEntity } from '../typings';
+import type { Type, types } from '../types';
+import type { EntityManager } from '../EntityManager';
+export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
+export type PropertyOptions<Owner> = {
+    /**
+     * Alias for `fieldName`.
+     */
+    name?: string;
+    /**
+     * Specify database column name for this property.
+     *
+     * @see https://mikro-orm.io/docs/naming-strategy
+     */
+    fieldName?: string;
+    /**
+     * Specify database column names for this property.
+     * Same as `fieldName` but for composite FKs.
+     *
+     * @see https://mikro-orm.io/docs/naming-strategy
+     */
+    fieldNames?: string[];
+    /**
+     * Specify exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    columnType?: ColumnType | AnyString;
+    /**
+     * Explicitly specify the runtime type.
+     *
+     * @see https://mikro-orm.io/docs/metadata-providers
+     * @see https://mikro-orm.io/docs/custom-types
+     */
+    type?: keyof typeof types | 'ObjectId' | Date | Constructor<AnyEntity> | Constructor<Type<any>> | Type<any> | (() => unknown) | ColumnType | AnyString;
+    /**
+     * Set length of database column, used for datetime/timestamp/varchar column types for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    length?: number;
+    /**
+     * Set precision of database column to represent the number of significant digits. (SQL only)
+     */
+    precision?: number;
+    /**
+     * Set scale of database column to represents the number of digits after the decimal point. (SQL only)
+     */
+    scale?: number;
+    /**
+     * Explicitly specify the auto increment of the primary key.
+     */
+    autoincrement?: boolean;
+    /**
+     * Add the property to the `returning` statement.
+     */
+    returning?: boolean;
+    /**
+     * Automatically set the property value when entity gets created, executed during flush operation.
+     * @param entity
+     */
+    onCreate?: (entity: Owner, em: EntityManager) => any;
+    /**
+     * Automatically update the property value every time entity gets updated, executed during flush operation.
+     * @param entity
+     */
+    onUpdate?: (entity: Owner, em: EntityManager) => any;
+    /**
+     * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
+     * This is a runtime value, assignable to the entity property. (SQL only)
+     */
+    default?: string | string[] | number | number[] | boolean | null;
+    /**
+     * Specify SQL functions for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * Since v4 you should use defaultRaw for SQL functions. e.g. now()
+     */
+    defaultRaw?: string;
+    /**
+     * Set to map some SQL snippet for the entity.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
+     */
+    formula?: string | ((alias: string) => string);
+    /**
+     * For generated columns. This will be appended to the column type after the `generated always` clause.
+     */
+    generated?: string | GeneratedColumnCallback<Owner>;
+    /**
+     * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
+     */
+    nullable?: boolean;
+    /**
+     * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    unsigned?: boolean;
+    /**
+     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
+     */
+    persist?: boolean;
+    /**
+     * Set false to disable hydration of this property. Useful for persisted getters.
+     */
+    hydrate?: boolean;
+    /**
+     * Enable `ScalarReference` wrapper for lazy values. Use this in combination with `lazy: true` to have a type-safe accessor object in place of the value.
+     */
+    ref?: boolean;
+    /**
+     * Set false to disable change tracking on a property level.
+     *
+     * @see https://mikro-orm.io/docs/unit-of-work#change-tracking-and-performance-considerations
+     */
+    trackChanges?: boolean;
+    /**
+     * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
+     */
+    hidden?: boolean;
+    /**
+     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
+     */
+    version?: boolean;
+    /**
+     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
+     */
+    concurrencyCheck?: boolean;
+    /**
+     * Explicitly specify index on a property.
+     */
+    index?: boolean | string;
+    /**
+     * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    unique?: boolean | string;
+    /**
+     * Specify column with check constraints. (Postgres driver only)
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#check-constraints
+     */
+    check?: string | CheckCallback<Owner>;
+    /**
+     * Set to omit the property from the select clause for lazy loading.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
+     */
+    lazy?: boolean;
+    /**
+     * Set true to define entity's unique primary key identifier.
+     * Alias for `@PrimaryKey()` decorator
+     *
+     * @see https://mikro-orm.io/docs/decorators#primarykey
+     */
+    primary?: boolean;
+    /**
+     * Set true to define the properties as setter. (virtual)
+     *
+     * @example
+     * ```
+     * @Property({ setter: true })
+     * set address(value: string) {
+     *     this._address = value.toLocaleLowerCase();
+     * }
+     * ```
+     */
+    setter?: boolean;
+    /**
+     * Set true to define the properties as getter. (virtual)
+     *
+     * @example
+     * ```
+     * @Property({ getter: true })
+     * get fullName() {
+     *   return this.firstName + this.lastName;
+     * }
+     * ```
+     */
+    getter?: boolean;
+    /**
+     * Set to define serialized primary key for MongoDB. (virtual)
+     * Alias for `@SerializedPrimaryKey()` decorator.
+     *
+     * @see https://mikro-orm.io/docs/decorators#serializedprimarykey
+     */
+    serializedPrimaryKey?: boolean;
+    /**
+     * Set to use serialize property. Allow to specify a callback that will be used when serializing a property.
+     *
+     * @see https://mikro-orm.io/docs/serializing#property-serializers
+     */
+    serializer?: (value: any) => any;
+    /**
+     * Specify name of key for the serialized value.
+     */
+    serializedName?: string;
+    /**
+     * Specify a custom order based on the values. (SQL only)
+     */
+    customOrder?: string[] | number[] | boolean[];
+    /**
+     * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    comment?: string;
+    /** mysql only */
+    extra?: string;
+    /**
+     * Set to avoid a perpetual diff from the {@link https://mikro-orm.io/docs/schema-generator Schema Generator} when columns are generated.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
+     */
+    ignoreSchemaChanges?: ('type' | 'extra')[];
+};
+export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
+    entity?: string | (() => EntityName<Target>);
+    cascade?: Cascade[];
+    eager?: boolean;
+    strategy?: LoadStrategy;
+}
+/**
+ * Inspired by https://github.com/typeorm/typeorm/blob/941b584ba135617e55d6685caef671172ec1dc03/src/driver/types/ColumnTypes.ts
+ * @ignore
+ */
+export type ColumnType = 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' | 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' | 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'boolean' | 'bool' | 'bit' | 'enum' | 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' | 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' | 'tsvector' | 'tsquery' | 'json' | 'jsonb';

package/decorators/Property.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = void 0;
+const metadata_1 = require("../metadata");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+function Property(options = {}) {
+    return function (target, propertyName) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
+        metadata_1.MetadataValidator.validateSingleDecorator(meta, propertyName, enums_1.ReferenceKind.SCALAR);
+        const name = options.name || propertyName;
+        if (propertyName !== name && !(desc.value instanceof Function)) {
+            utils_1.Utils.renameKey(options, 'name', 'fieldName');
+        }
+        options.name = propertyName;
+        const { check, ...opts } = options;
+        const prop = { kind: enums_1.ReferenceKind.SCALAR, ...opts };
+        prop.getter = !!desc.get;
+        prop.setter = !!desc.set;
+        if (desc.value instanceof Function) {
+            prop.getter = true;
+            prop.persist = false;
+            prop.type = 'method';
+            prop.getterName = propertyName;
+            prop.name = name;
+        }
+        if (check) {
+            meta.checks.push({ property: prop.name, expression: check });
+        }
+        meta.properties[prop.name] = prop;
+        return utils_1.Utils.propertyDecoratorReturnValue();
+    };
+}
+exports.Property = Property;

package/decorators/Subscriber.d.ts

@@ -0,0 +1 @@
+export {};

package/decorators/Subscriber.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/decorators/hooks.d.ts

@@ -0,0 +1,16 @@
+export declare function BeforeCreate(): (target: any, method: string) => void;
+export declare function AfterCreate(): (target: any, method: string) => void;
+export declare function BeforeUpdate(): (target: any, method: string) => void;
+export declare function AfterUpdate(): (target: any, method: string) => void;
+export declare function BeforeUpsert(): (target: any, method: string) => void;
+export declare function AfterUpsert(): (target: any, method: string) => void;
+export declare function OnInit(): (target: any, method: string) => void;
+export declare function OnLoad(): (target: any, method: string) => void;
+/**
+ * Called before deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export declare function BeforeDelete(): (target: any, method: string) => void;
+/**
+ * Called after deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export declare function AfterDelete(): (target: any, method: string) => void;

package/decorators/hooks.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AfterDelete = exports.BeforeDelete = exports.OnLoad = exports.OnInit = exports.AfterUpsert = exports.BeforeUpsert = exports.AfterUpdate = exports.BeforeUpdate = exports.AfterCreate = exports.BeforeCreate = void 0;
+const metadata_1 = require("../metadata");
+const enums_1 = require("../enums");
+function hook(type) {
+    return function (target, method) {
+        const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(target.constructor);
+        if (!meta.hooks[type]) {
+            meta.hooks[type] = [];
+        }
+        meta.hooks[type].push(method);
+    };
+}
+function BeforeCreate() {
+    return hook(enums_1.EventType.beforeCreate);
+}
+exports.BeforeCreate = BeforeCreate;
+function AfterCreate() {
+    return hook(enums_1.EventType.afterCreate);
+}
+exports.AfterCreate = AfterCreate;
+function BeforeUpdate() {
+    return hook(enums_1.EventType.beforeUpdate);
+}
+exports.BeforeUpdate = BeforeUpdate;
+function AfterUpdate() {
+    return hook(enums_1.EventType.afterUpdate);
+}
+exports.AfterUpdate = AfterUpdate;
+function BeforeUpsert() {
+    return hook(enums_1.EventType.beforeUpsert);
+}
+exports.BeforeUpsert = BeforeUpsert;
+function AfterUpsert() {
+    return hook(enums_1.EventType.afterUpsert);
+}
+exports.AfterUpsert = AfterUpsert;
+function OnInit() {
+    return hook(enums_1.EventType.onInit);
+}
+exports.OnInit = OnInit;
+function OnLoad() {
+    return hook(enums_1.EventType.onLoad);
+}
+exports.OnLoad = OnLoad;
+/**
+ * Called before deleting entity, but only when providing initialized entity to EM#remove()
+ */
+function BeforeDelete() {
+    return hook(enums_1.EventType.beforeDelete);
+}
+exports.BeforeDelete = BeforeDelete;
+/**
+ * Called after deleting entity, but only when providing initialized entity to EM#remove()
+ */
+function AfterDelete() {
+    return hook(enums_1.EventType.afterDelete);
+}
+exports.AfterDelete = AfterDelete;

package/decorators/index.d.ts

@@ -0,0 +1,17 @@
+export * from './PrimaryKey';
+export * from './Entity';
+export * from './OneToOne';
+export * from './ManyToOne';
+export * from './ManyToMany';
+export { OneToMany, OneToManyOptions } from './OneToMany';
+export * from './Property';
+export * from './Check';
+export * from './Enum';
+export * from './Formula';
+export * from './Indexed';
+export * from './Embeddable';
+export * from './Embedded';
+export * from './Filter';
+export * from './CreateRequestContext';
+export * from './EnsureRequestContext';
+export * from './hooks';

package/decorators/index.js

@@ -0,0 +1,36 @@
+"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 });
+exports.OneToMany = void 0;
+/* istanbul ignore file */
+__exportStar(require("./PrimaryKey"), exports);
+__exportStar(require("./Entity"), exports);
+__exportStar(require("./OneToOne"), exports);
+__exportStar(require("./ManyToOne"), exports);
+__exportStar(require("./ManyToMany"), exports);
+var OneToMany_1 = require("./OneToMany");
+Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function () { return OneToMany_1.OneToMany; } });
+__exportStar(require("./Property"), exports);
+__exportStar(require("./Check"), exports);
+__exportStar(require("./Enum"), exports);
+__exportStar(require("./Formula"), exports);
+__exportStar(require("./Indexed"), exports);
+__exportStar(require("./Embeddable"), exports);
+__exportStar(require("./Embedded"), exports);
+__exportStar(require("./Filter"), exports);
+__exportStar(require("./CreateRequestContext"), exports);
+__exportStar(require("./EnsureRequestContext"), exports);
+__exportStar(require("./hooks"), exports);

package/drivers/DatabaseDriver.d.ts

@@ -0,0 +1,72 @@
+import { EntityManagerType, type CountOptions, type LockOptions, type DeleteOptions, type FindOneOptions, type FindOptions, type IDatabaseDriver, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type DriverMethodOptions, type OrderDefinition } from './IDatabaseDriver';
+import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings';
+import type { MetadataStorage } from '../metadata';
+import type { Connection, QueryResult, Transaction } from '../connections';
+import { EntityComparator, type Configuration, type ConnectionOptions } from '../utils';
+import { type QueryOrder } from '../enums';
+import type { Platform } from '../platforms';
+import type { Collection } from '../entity/Collection';
+import { EntityManager } from '../EntityManager';
+import { DriverException } from '../exceptions';
+import type { Logger } from '../logging/Logger';
+export declare abstract class DatabaseDriver<C extends Connection> implements IDatabaseDriver<C> {
+    readonly config: Configuration;
+    protected readonly dependencies: string[];
+    [EntityManagerType]: EntityManager<this>;
+    protected readonly connection: C;
+    protected readonly replicas: C[];
+    protected readonly platform: Platform;
+    protected readonly logger: Logger;
+    protected comparator: EntityComparator;
+    protected metadata: MetadataStorage;
+    protected constructor(config: Configuration, dependencies: string[]);
+    abstract find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    abstract findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    abstract nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
+    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
+    mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
+    connect(): Promise<C>;
+    reconnect(): Promise<C>;
+    getConnection(type?: ConnectionType): C;
+    close(force?: boolean): Promise<void>;
+    getPlatform(): Platform;
+    setMetadata(metadata: MetadataStorage): void;
+    getMetadata(): MetadataStorage;
+    getDependencies(): string[];
+    protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
+        orderBy: OrderDefinition<T>[];
+        where: FilterQuery<T>;
+    };
+    protected createCursorCondition<T extends object>(definition: (readonly [keyof T & string, QueryOrder])[], offsets: Dictionary[], inverse: boolean): FilterQuery<T>;
+    /** @internal */
+    mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;
+    protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;
+    protected getPrimaryKeyFields(entityName: string): string[];
+    protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
+    lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    convertException(exception: Error): DriverException;
+    protected rethrow<T>(promise: Promise<T>): Promise<T>;
+    /**
+     * @internal
+     */
+    getTableName<T>(meta: EntityMetadata<T>, options: NativeInsertUpdateManyOptions<T>): string;
+    /**
+     * @internal
+     */
+    getSchemaName(meta?: EntityMetadata, options?: {
+        schema?: string;
+    }): string | undefined;
+}