@mikro-orm/core 7.0.0-dev.32 → 7.0.0-dev.321

package/entity/defineEntity.js

@@ -1,17 +1,25 @@
 import { types } from '../types/index.js';
 import { EntitySchema } from '../metadata/EntitySchema.js';
+// Parameter-level sync assertion lives in tests/defineEntity.test.ts to avoid
+// instantiating the full builder class in production builds (~680 instantiations).
 /** @internal */
-export class PropertyOptionsBuilder {
+export class UniversalPropertyOptionsBuilder {
     '~options';
     '~type';
     constructor(options) {
         this['~options'] = options;
     }
+    assignOptions(options) {
+        return new UniversalPropertyOptionsBuilder({ ...this['~options'], ...options });
+    }
+    $type() {
+        return this.assignOptions({});
+    }
     /**
      * Alias for `fieldName`.
      */
     name(name) {
-        return new PropertyOptionsBuilder({ ...this['~options'], name });
+        return this.assignOptions({ name });
     }
     /**
      * Specify database column name for this property.
@@ -19,7 +27,7 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/naming-strategy
      */
     fieldName(fieldName) {
-        return new PropertyOptionsBuilder({ ...this['~options'], fieldName });
+        return this.assignOptions({ fieldName });
     }
     /**
      * Specify database column names for this property.
@@ -28,19 +36,19 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/naming-strategy
      */
     fieldNames(...fieldNames) {
-        return new PropertyOptionsBuilder({ ...this['~options'], fieldNames });
+        return this.assignOptions({ fieldNames });
     }
     /**
      * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is only for simple properties represented by a single column. (SQL only)
      */
     columnType(columnType) {
-        return new PropertyOptionsBuilder({ ...this['~options'], columnType });
+        return this.assignOptions({ columnType });
     }
     /**
      * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is suitable for composite keys, where one property is represented by multiple columns. (SQL only)
      */
     columnTypes(...columnTypes) {
-        return new PropertyOptionsBuilder({ ...this['~options'], columnTypes });
+        return this.assignOptions({ columnTypes });
     }
     /**
      * Explicitly specify the runtime type.
@@ -49,72 +57,73 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/custom-types
      */
     type(type) {
-        return new PropertyOptionsBuilder({ ...this['~options'], type });
+        return this.assignOptions({ type });
     }
     /**
      * Runtime type of the property. This is the JS type that your property is mapped to, e.g. `string` or `number`, and is normally inferred automatically via `reflect-metadata`.
      * In some cases, the inference won't work, and you might need to specify the `runtimeType` explicitly - the most common one is when you use a union type with null like `foo: number | null`.
      */
     runtimeType(runtimeType) {
-        return new PropertyOptionsBuilder({ ...this['~options'], runtimeType });
+        return this.assignOptions({ runtimeType });
     }
     /**
      * 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(length) {
-        return new PropertyOptionsBuilder({ ...this['~options'], length });
+        return this.assignOptions({ length });
     }
     /**
      * Set precision of database column to represent the number of significant digits. (SQL only)
      */
     precision(precision) {
-        return new PropertyOptionsBuilder({ ...this['~options'], precision });
+        return this.assignOptions({ precision });
     }
     /**
      * Set scale of database column to represents the number of digits after the decimal point. (SQL only)
      */
     scale(scale) {
-        return new PropertyOptionsBuilder({ ...this['~options'], scale });
+        return this.assignOptions({ scale });
     }
-    /**
-     * Explicitly specify the auto increment of the primary key.
-     */
     autoincrement(autoincrement = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], autoincrement });
+        return this.assignOptions({ autoincrement });
     }
     /**
      * Add the property to the `returning` statement.
      */
     returning(returning = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], returning });
+        return this.assignOptions({ returning });
     }
     /**
      * Automatically set the property value when entity gets created, executed during flush operation.
-     * @param entity
      */
     onCreate(onCreate) {
-        return new PropertyOptionsBuilder({ ...this['~options'], onCreate });
+        return this.assignOptions({ onCreate });
     }
     /**
      * Automatically update the property value every time entity gets updated, executed during flush operation.
-     * @param entity
      */
     onUpdate(onUpdate) {
-        return new PropertyOptionsBuilder({ ...this['~options'], onUpdate });
+        return this.assignOptions({ onUpdate });
     }
     /**
      * 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(defaultValue) {
-        return new PropertyOptionsBuilder({ ...this['~options'], default: defaultValue });
+        return this.assignOptions({ default: defaultValue });
     }
     /**
      * 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(defaultRaw) {
-        return new PropertyOptionsBuilder({ ...this['~options'], defaultRaw });
+        return this.assignOptions({ defaultRaw });
+    }
+    /**
+     * Allow controlling `filters` option. This will be overridden with `em.fork` or `FindOptions` if provided.
+     */
+    filters(filters) {
+        return this.assignOptions({ filters });
     }
     /**
      * Set to map some SQL snippet for the entity.
@@ -122,81 +131,70 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
      */
     formula(formula) {
-        return new PropertyOptionsBuilder({ ...this['~options'], formula });
+        return this.assignOptions({ formula });
     }
     /**
      * For generated columns. This will be appended to the column type after the `generated always` clause.
      */
     generated(generated) {
-        return new PropertyOptionsBuilder({ ...this['~options'], generated });
+        return this.assignOptions({ generated });
     }
     /**
      * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      */
-    nullable(nullable = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], nullable });
+    nullable() {
+        return this.assignOptions({ nullable: true });
     }
     /**
      * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
     unsigned(unsigned = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], unsigned });
+        return this.assignOptions({ unsigned });
     }
-    /**
-     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
-     */
     persist(persist = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], persist });
+        return this.assignOptions({ persist });
     }
     /**
      * Set false to disable hydration of this property. Useful for persisted getters.
      */
     hydrate(hydrate = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], hydrate });
+        return this.assignOptions({ hydrate });
     }
     /**
      * 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(ref = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], ref });
-    }
-    /**
-     * 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(trackChanges = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], trackChanges });
+    ref() {
+        return this.assignOptions({ ref: true });
     }
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
-    hidden(hidden = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], hidden });
+    hidden() {
+        return this.assignOptions({ hidden: true });
     }
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
      */
-    version(version = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], version });
+    version() {
+        return this.assignOptions({ version: true });
     }
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
      */
     concurrencyCheck(concurrencyCheck = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], concurrencyCheck });
+        return this.assignOptions({ concurrencyCheck });
     }
     /**
      * Explicitly specify index on a property.
      */
     index(index = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], index });
+        return this.assignOptions({ index });
     }
     /**
      * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
     unique(unique = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], unique });
+        return this.assignOptions({ unique });
     }
     /**
      * Specify column with check constraints. (Postgres driver only)
@@ -204,23 +202,23 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/defining-entities#check-constraints
      */
     check(check) {
-        return new PropertyOptionsBuilder({ ...this['~options'], check });
+        return this.assignOptions({ check });
     }
     /**
      * Set to omit the property from the select clause for lazy loading.
      *
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
-    lazy(lazy = true, ref = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], lazy, ref });
+    lazy() {
+        return this.assignOptions({ lazy: true });
     }
     /**
      * Set true to define entity's unique primary key identifier.
      *
      * @see https://mikro-orm.io/docs/decorators#primarykey
      */
-    primary(primary = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], primary });
+    primary() {
+        return this.assignOptions({ primary: true });
     }
     /**
      * Set true to define the properties as setter. (virtual)
@@ -234,7 +232,7 @@ export class PropertyOptionsBuilder {
      * ```
      */
     setter(setter = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], setter });
+        return this.assignOptions({ setter });
     }
     /**
      * Set true to define the properties as getter. (virtual)
@@ -248,7 +246,7 @@ export class PropertyOptionsBuilder {
      * ```
      */
     getter(getter = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], getter });
+        return this.assignOptions({ getter });
     }
     /**
      * When defining a property over a method (not a getter, a regular function), you can use this option to point
@@ -263,7 +261,7 @@ export class PropertyOptionsBuilder {
      * ```
      */
     getterName(getterName) {
-        return new PropertyOptionsBuilder({ ...this['~options'], getterName });
+        return this.assignOptions({ getterName });
     }
     /**
      * Set to define serialized primary key for MongoDB. (virtual)
@@ -272,7 +270,7 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/decorators#serializedprimarykey
      */
     serializedPrimaryKey(serializedPrimaryKey = true) {
-        return new PropertyOptionsBuilder({ ...this['~options'], serializedPrimaryKey });
+        return this.assignOptions({ serializedPrimaryKey });
     }
     /**
      * Set to use serialize property. Allow to specify a callback that will be used when serializing a property.
@@ -280,36 +278,36 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/serializing#property-serializers
      */
     serializer(serializer) {
-        return new PropertyOptionsBuilder({ ...this['~options'], serializer });
+        return this.assignOptions({ serializer });
     }
     /**
      * Specify name of key for the serialized value.
      */
     serializedName(serializedName) {
-        return new PropertyOptionsBuilder({ ...this['~options'], serializedName });
+        return this.assignOptions({ serializedName });
     }
     /**
      * Specify serialization groups for `serialize()` calls. If a property does not specify any group, it will be included,
      * otherwise only properties with a matching group are included.
      */
     groups(...groups) {
-        return new PropertyOptionsBuilder({ ...this['~options'], groups });
+        return this.assignOptions({ groups });
     }
     /**
      * Specify a custom order based on the values. (SQL only)
      */
     customOrder(...customOrder) {
-        return new PropertyOptionsBuilder({ ...this['~options'], customOrder });
+        return this.assignOptions({ customOrder });
     }
     /**
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
     comment(comment) {
-        return new PropertyOptionsBuilder({ ...this['~options'], comment });
+        return this.assignOptions({ comment });
     }
     /** mysql only */
     extra(extra) {
-        return new PropertyOptionsBuilder({ ...this['~options'], extra });
+        return this.assignOptions({ extra });
     }
     /**
      * Set to avoid a perpetual diff from the {@link https://mikro-orm.io/docs/schema-generator Schema Generator} when columns are generated.
@@ -317,342 +315,187 @@ export class PropertyOptionsBuilder {
      * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
      */
     ignoreSchemaChanges(...ignoreSchemaChanges) {
-        return new PropertyOptionsBuilder({ ...this['~options'], ignoreSchemaChanges });
+        return this.assignOptions({ ignoreSchemaChanges });
     }
-    $type() {
-        return new PropertyOptionsBuilder({ ...this['~options'] });
-    }
-}
-/** @internal */
-export class EnumOptionsBuilder extends PropertyOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    array(array = true) {
-        return new EnumOptionsBuilder({ ...this['~options'], array });
+    array() {
+        return this.assignOptions({ array: true });
     }
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName(nativeEnumName) {
-        return new EnumOptionsBuilder({ ...this['~options'], nativeEnumName });
-    }
-}
-/** @internal */
-export class EmbeddedOptionsBuilder extends PropertyOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
+        return this.assignOptions({ nativeEnumName });
     }
     prefix(prefix) {
-        return new EmbeddedOptionsBuilder({ ...this['~options'], prefix });
+        return this.assignOptions({ prefix });
     }
     prefixMode(prefixMode) {
-        return new EmbeddedOptionsBuilder({ ...this['~options'], prefixMode });
+        return this.assignOptions({ prefixMode });
     }
     object(object = true) {
-        return new EmbeddedOptionsBuilder({ ...this['~options'], object });
-    }
-    array(array = true) {
-        return new EmbeddedOptionsBuilder({ ...this['~options'], array });
-    }
-}
-/** @internal */
-export class ReferenceOptionsBuilder extends PropertyOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
+        return this.assignOptions({ object });
     }
     /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade(...cascade) {
-        return new ReferenceOptionsBuilder({ ...this['~options'], cascade });
+        return this.assignOptions({ cascade });
     }
     /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
     eager(eager = true) {
-        return new ReferenceOptionsBuilder({ ...this['~options'], eager });
+        return this.assignOptions({ eager });
     }
     /** Override the default loading strategy for this property. This option has precedence over the global `loadStrategy`, but can be overridden by `FindOptions.strategy`. */
     strategy(strategy) {
-        return new ReferenceOptionsBuilder({ ...this['~options'], strategy });
+        return this.assignOptions({ strategy });
     }
-    /**
-     * @internal
-     * re-declare to override type inference
-     */
-    /* v8 ignore next 3 */
-    ref(ref = true) {
-        return new ReferenceOptionsBuilder({ ...this['~options'], ref });
-    }
-    /**
-     * @internal
-     * re-declare to override type inference
-     */
-    /* v8 ignore next 3 */
-    primary(primary = true) {
-        return new ReferenceOptionsBuilder({ ...this['~options'], primary });
+    /** 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() {
+        return this.assignOptions({ owner: true });
     }
-}
-/** @internal */
-export class ManyToManyOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
+    /** For polymorphic relations. Specifies the property name that stores the entity type discriminator. Defaults to the property name. */
+    discriminator(discriminator) {
+        return this.assignOptions({ discriminator });
     }
-    /** 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(owner = true) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], owner });
+    /** For polymorphic relations. Custom mapping of discriminator values to entity class names. */
+    discriminatorMap(discriminatorMap) {
+        return this.assignOptions({ discriminatorMap });
     }
     /** Point to the inverse side property name. */
     inversedBy(inversedBy) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], inversedBy });
+        return this.assignOptions({ inversedBy });
     }
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], mappedBy });
+        return this.assignOptions({ mappedBy });
     }
     /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
     where(...where) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], where: where });
+        return this.assignOptions({ where });
     }
     /** Set default ordering. */
     orderBy(...orderBy) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], orderBy });
+        return this.assignOptions({ orderBy });
     }
     /** Force stable insertion order of items in the collection (see {@doclink collections | Collections}). */
     fixedOrder(fixedOrder = true) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], fixedOrder });
+        return this.assignOptions({ fixedOrder });
     }
     /** Override default order column name (`id`) for fixed ordering. */
     fixedOrderColumn(fixedOrderColumn) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], fixedOrderColumn });
+        return this.assignOptions({ fixedOrderColumn });
     }
     /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable(pivotTable) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], pivotTable });
+        return this.assignOptions({ pivotTable });
     }
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
     pivotEntity(pivotEntity) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], pivotEntity });
+        return this.assignOptions({ pivotEntity });
     }
     /** 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(joinColumn) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], joinColumn });
+        return this.assignOptions({ joinColumn });
     }
     /** 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(...joinColumns) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], joinColumns });
+        return this.assignOptions({ joinColumns });
     }
     /** 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(inverseJoinColumn) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], inverseJoinColumn });
+        return this.assignOptions({ inverseJoinColumn });
     }
     /** 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(...inverseJoinColumns) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], inverseJoinColumns });
+        return this.assignOptions({ inverseJoinColumns });
     }
     /** 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(referenceColumnName) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], referenceColumnName });
+        return this.assignOptions({ referenceColumnName });
     }
     /** 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(...referencedColumnNames) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], referencedColumnNames });
+        return this.assignOptions({ referencedColumnNames });
+    }
+    /** Specify the property name on the target entity that this FK references instead of the primary key. */
+    targetKey(targetKey) {
+        return this.assignOptions({ targetKey });
     }
     /** What to do when the target entity gets deleted. */
     deleteRule(deleteRule) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], deleteRule });
+        return this.assignOptions({ deleteRule });
     }
     /** What to do when the reference to the target entity gets updated. */
     updateRule(updateRule) {
-        return new ManyToManyOptionsBuilder({ ...this['~options'], updateRule });
-    }
-}
-/** @internal */
-export class ManyToOneOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    /** Point to the inverse side property name. */
-    inversedBy(inversedBy) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], inversedBy });
-    }
-    /** Wrap the entity in {@apilink Reference} wrapper. */
-    ref(ref = true) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], ref });
-    }
-    /** Use this relation as a primary key. */
-    primary(primary = true) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], primary });
+        return this.assignOptions({ updateRule });
     }
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk = true) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], mapToPk });
-    }
-    /** 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(joinColumn) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], joinColumn });
+    mapToPk() {
+        return this.assignOptions({ mapToPk: true });
     }
-    /** 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(...joinColumns) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], joinColumns });
+    /** 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) {
+        return this.assignOptions({ deferMode });
     }
     /** 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(...ownColumns) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], ownColumns });
+        return this.assignOptions({ ownColumns });
     }
-    /** 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(referenceColumnName) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], referenceColumnName });
+    /** Enable/disable foreign key constraint creation on this relation */
+    createForeignKeyConstraint(createForeignKeyConstraint = true) {
+        return this.assignOptions({ createForeignKeyConstraint });
     }
-    /** 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(...referencedColumnNames) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], referencedColumnNames });
-    }
-    /** What to do when the target entity gets deleted. */
-    deleteRule(deleteRule) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], deleteRule });
-    }
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule(updateRule) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], updateRule });
-    }
-    /** 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) {
-        return new ManyToOneOptionsBuilder({ ...this['~options'], deferMode });
-    }
-}
-/** @internal */
-export class OneToManyOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
+    /** Set a custom foreign key constraint name, overriding NamingStrategy.indexName(). */
+    foreignKeyName(foreignKeyName) {
+        return this.assignOptions({ foreignKeyName });
     }
     /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval(orphanRemoval = true) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], orphanRemoval });
-    }
-    /** Set default ordering. */
-    orderBy(orderBy) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], orderBy });
-    }
-    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
-    where(where) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], where });
-    }
-    /** 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(joinColumn) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], joinColumn });
-    }
-    /** 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(...joinColumns) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], joinColumns });
-    }
-    /** 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(inverseJoinColumn) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], inverseJoinColumn });
-    }
-    /** 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(...inverseJoinColumns) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], inverseJoinColumns });
-    }
-    /** 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(referenceColumnName) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], referenceColumnName });
+        return this.assignOptions({ orphanRemoval });
     }
-    /** 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(...referencedColumnNames) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], referencedColumnNames });
+    accessor(accessor = true) {
+        return this.assignOptions({ accessor });
     }
 }
 /** @internal */
-export class OneToManyOptionsBuilderOnlyMappedBy {
-    constructor(options) {
-        this['~options'] = options;
-    }
+export class OneToManyOptionsBuilderOnlyMappedBy extends UniversalPropertyOptionsBuilder {
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
-        return new OneToManyOptionsBuilder({ ...this['~options'], mappedBy });
-    }
-}
-/** @internal */
-export class OneToOneOptionsBuilder extends ReferenceOptionsBuilder {
-    constructor(options) {
-        super(options);
-        this['~options'] = options;
-    }
-    /** 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(owner = true) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], owner });
-    }
-    /** Point to the inverse side property name. */
-    inversedBy(inversedBy) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], inversedBy });
-    }
-    /** Wrap the entity in {@apilink Reference} wrapper. */
-    ref(ref = true) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], ref });
-    }
-    /** Use this relation as a primary key. */
-    primary(primary = true) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], primary });
-    }
-    /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk = true) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], mapToPk });
-    }
-    /** 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(...ownColumns) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], ownColumns });
-    }
-    /** What to do when the target entity gets deleted. */
-    deleteRule(deleteRule) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], deleteRule });
-    }
-    /** What to do when the reference to the target entity gets updated. */
-    updateRule(updateRule) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], updateRule });
-    }
-    /** 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) {
-        return new OneToOneOptionsBuilder({ ...this['~options'], deferMode });
+        return new UniversalPropertyOptionsBuilder({ ...this['~options'], mappedBy });
     }
 }
 function createPropertyBuilders(options) {
-    return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, () => new PropertyOptionsBuilder({ type: value })]));
+    return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, () => new UniversalPropertyOptionsBuilder({ type: value })]));
 }
 const propertyBuilders = {
     ...createPropertyBuilders(types),
-    bigint: (mode) => new PropertyOptionsBuilder({ type: new types.bigint(mode) }),
-    array: (toJsValue = i => i, toDbValue = i => i) => new PropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
-    decimal: (mode) => new PropertyOptionsBuilder({ type: new types.decimal(mode) }),
-    json: () => new PropertyOptionsBuilder({ type: types.json }),
-    formula: (formula) => new PropertyOptionsBuilder({ formula }),
-    type: (type) => new PropertyOptionsBuilder({ type }),
-    enum: (items) => new EnumOptionsBuilder({
+    bigint: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.bigint(mode) }),
+    array: (toJsValue = i => i, toDbValue = i => i) => new UniversalPropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
+    decimal: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.decimal(mode) }),
+    json: () => new UniversalPropertyOptionsBuilder({ type: types.json }),
+    formula: (formula) => new UniversalPropertyOptionsBuilder({ formula }),
+    datetime: (length) => new UniversalPropertyOptionsBuilder({ type: types.datetime, length }),
+    time: (length) => new UniversalPropertyOptionsBuilder({ type: types.time, length }),
+    type: (type) => new UniversalPropertyOptionsBuilder({ type }),
+    enum: (items) => new UniversalPropertyOptionsBuilder({
         enum: true,
         items,
     }),
-    embedded: (target) => new EmbeddedOptionsBuilder({
+    embedded: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: 'embedded',
     }),
-    manyToMany: (target) => new ManyToManyOptionsBuilder({
+    manyToMany: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: 'm:n',
     }),
-    manyToOne: (target) => new ManyToOneOptionsBuilder({
+    manyToOne: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: 'm:1',
-        ref: true,
     }),
     oneToMany: (target) => new OneToManyOptionsBuilderOnlyMappedBy({
         entity: () => target,
         kind: '1:m',
     }),
-    oneToOne: (target) => new OneToOneOptionsBuilder({
+    oneToOne: (target) => new UniversalPropertyOptionsBuilder({
         entity: () => target,
         kind: '1:1',
-        ref: true,
     }),
 };
 function getBuilderOptions(builder) {
@@ -662,8 +505,8 @@ export function defineEntity(meta) {
     const { properties: propertiesOrGetter, ...options } = meta;
     const propertyOptions = typeof propertiesOrGetter === 'function' ? propertiesOrGetter(propertyBuilders) : propertiesOrGetter;
     const properties = {};
+    const values = new Map();
     for (const [key, builder] of Object.entries(propertyOptions)) {
-        const values = new Map();
         if (typeof builder === 'function') {
             Object.defineProperty(properties, key, {
                 get: () => {
@@ -691,3 +534,4 @@ export function defineEntity(meta) {
     return new EntitySchema({ properties, ...options });
 }
 defineEntity.properties = propertyBuilders;
+export { propertyBuilders as p };