@mikro-orm/core 7.0.0-dev.7 → 7.0.0-dev.71

package/utils/upsert-utils.js

@@ -1,3 +1,5 @@
+import { isRaw } from '../utils/RawQueryFragment.js';
+import { Utils } from './Utils.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -71,7 +73,15 @@ export function getOnConflictReturningFields(meta, data, uniqueFields, options)
     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;
-}

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,30 +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}`;
-}

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();
-    };
-}

package/decorators/OneToMany.d.ts

@@ -1,28 +0,0 @@
-import type { ReferenceOptions } from './Property.js';
-import { ReferenceKind, type QueryOrderMap } from '../enums.js';
-import type { EntityName, FilterQuery } from '../typings.js';
-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: Owner, 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: Owner, propertyName: string) => void;
-export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
-export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
-    /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
-    orphanRemoval?: boolean;
-    /** Set default ordering. */
-    orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
-    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
-    where?: FilterQuery<Target>;
-    /** 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[];
-    /** Point to the owning side property name. */
-    mappedBy: (string & keyof Target) | ((e: Target) => any);
-}

package/decorators/OneToMany.js

@@ -1,17 +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 createOneToDecorator(entity, mappedBy, options, kind) {
-    return function (target, propertyName) {
-        options = Utils.processDecoratorParameters({ entity, mappedBy, options });
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, kind);
-        const property = { name: propertyName, kind };
-        meta.properties[propertyName] = Object.assign(meta.properties[propertyName] ?? {}, property, options);
-        return Utils.propertyDecoratorReturnValue();
-    };
-}
-export function OneToMany(entity, mappedBy, options = {}) {
-    return createOneToDecorator(entity, mappedBy, options, ReferenceKind.ONE_TO_MANY);
-}

package/decorators/OneToOne.d.ts

@@ -1,24 +0,0 @@
-import { type DeferMode } from '../enums.js';
-import { type OneToManyOptions } from './OneToMany.js';
-import type { AnyString, EntityName } from '../typings.js';
-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: Owner, propertyName: string) => any;
-export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
-    /** 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);
-    /** 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;
-    /** 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[];
-    /** 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}`;
-}

package/decorators/OneToOne.js

@@ -1,7 +0,0 @@
-import { ReferenceKind } from '../enums.js';
-import { createOneToDecorator } from './OneToMany.js';
-export function OneToOne(entity, mappedByOrOptions, options = {}) {
-    const mappedBy = typeof mappedByOrOptions === 'object' ? mappedByOrOptions.mappedBy : mappedByOrOptions;
-    options = typeof mappedByOrOptions === 'object' ? { ...mappedByOrOptions, ...options } : options;
-    return createOneToDecorator(entity, mappedBy, options, ReferenceKind.ONE_TO_ONE);
-}

package/decorators/PrimaryKey.d.ts

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

package/decorators/PrimaryKey.js

@@ -1,20 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { ReferenceKind } from '../enums.js';
-import { Utils } from '../utils/Utils.js';
-function createDecorator(options, serialized) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
-        const k = serialized ? 'serializedPrimaryKey' : 'primary';
-        options[k] = true;
-        meta.properties[propertyName] = { name: propertyName, kind: ReferenceKind.SCALAR, ...options };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}
-export function PrimaryKey(options = {}) {
-    return createDecorator(options, false);
-}
-export function SerializedPrimaryKey(options = {}) {
-    return createDecorator(options, true);
-}