@mikro-orm/core 6.4.3-dev.8 → 6.4.3

package/decorators/OneToOne.d.ts

@@ -13,6 +13,8 @@ export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOp
     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. */

package/decorators/Property.d.ts

@@ -23,9 +23,13 @@ export interface PropertyOptions<Owner> {
      */
     fieldNames?: string[];
     /**
-     * Specify exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * 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 | AnyString;
+    /**
+     * 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?: (ColumnType | AnyString)[];
     /**
      * Explicitly specify the runtime type.
      *

package/errors.d.ts

@@ -38,6 +38,7 @@ export declare class OptimisticLockError<T extends AnyEntity = AnyEntity> extend
 export declare class MetadataError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static fromMissingPrimaryKey(meta: EntityMetadata): MetadataError;
     static fromWrongReference(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy', owner?: EntityProperty): MetadataError;
+    static fromWrongForeignKey(meta: EntityMetadata, prop: EntityProperty, key: string): MetadataError;
     static fromWrongTypeDefinition(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static fromWrongOwnership(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy'): MetadataError;
     static fromWrongReferenceKind(meta: EntityMetadata, owner: EntityProperty, prop: EntityProperty): MetadataError;

package/errors.js

@@ -138,6 +138,9 @@ class MetadataError extends ValidationError {
         }
         return MetadataError.fromMessage(meta, prop, `has unknown '${key}' reference: ${prop.type}.${prop[key]}`);
     }
+    static fromWrongForeignKey(meta, prop, key) {
+        return MetadataError.fromMessage(meta, prop, `requires explicit '${key}' option, since the 'joinColumns' are not matching the length.`);
+    }
     static fromWrongTypeDefinition(meta, prop) {
         if (!prop.type) {
             return MetadataError.fromMessage(meta, prop, `is missing type definition`);

package/metadata/MetadataDiscovery.js

@@ -364,7 +364,7 @@ class MetadataDiscovery {
     initOwnColumns(meta) {
         meta.sync();
         for (const prop of meta.props) {
-            if (!prop.joinColumns || prop.ownColumns) {
+            if (!prop.joinColumns || !prop.columnTypes || prop.ownColumns || ![enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                 continue;
             }
             if (prop.joinColumns.length > 1) {
@@ -375,6 +375,19 @@ class MetadataDiscovery {
             if (!prop.ownColumns || prop.ownColumns.length === 0) {
                 prop.ownColumns = prop.joinColumns;
             }
+            if (prop.joinColumns.length !== prop.columnTypes.length) {
+                prop.columnTypes = prop.joinColumns.flatMap(field => {
+                    const matched = meta.props.find(p => p.fieldNames?.includes(field));
+                    if (matched) {
+                        return matched.columnTypes;
+                    }
+                    /* istanbul ignore next */
+                    throw errors_1.MetadataError.fromWrongForeignKey(meta, prop, 'columnTypes');
+                });
+            }
+            if (prop.joinColumns.length !== prop.referencedColumnNames.length) {
+                throw errors_1.MetadataError.fromWrongForeignKey(meta, prop, 'referencedColumnNames');
+            }
         }
     }
     initFieldName(prop, object = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.3-dev.8",
+  "version": "6.4.3",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.3-dev.8",
+    "mikro-orm": "6.4.3",
     "reflect-metadata": "0.2.2"
   }
 }

package/utils/ConfigurationLoader.js

@@ -290,7 +290,10 @@ class ConfigurationLoader {
         read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_ALL_OR_NOTHING', 'allOrNothing', bool);
         read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_DROP_TABLES', 'dropTables', bool);
         read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SAFE', 'safe', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SILENT', 'silent', bool);
         read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_EMIT', 'emit');
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SNAPSHOT', 'snapshot', bool);
+        read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_SNAPSHOT_NAME', 'snapshotName');
         cleanup(ret, 'migrations');
         ret.schemaGenerator = {};
         read(ret.schemaGenerator, 'MIKRO_ORM_SCHEMA_GENERATOR_DISABLE_FOREIGN_KEYS', 'disableForeignKeys', bool);