@mikro-orm/core 7.1.0-dev.2 → 7.1.0-dev.4

package/EntityManager.d.ts

@@ -307,6 +307,25 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Fires native insert query. Calling this has no side effects on the context (identity map).
      */
     insert<Entity extends object>(entityNameOrEntity: EntityName<Entity> | Entity, data?: RequiredEntityData<Entity> | Entity, options?: NativeInsertUpdateOptions<Entity>): Promise<Primary<Entity>>;
+    /**
+     * Clones rows matching the condition at the database level via INSERT...SELECT.
+     * Automatically excludes auto-increment PKs, generated columns, and resets version properties.
+     * Returns the cloned entity, registered in the identity map.
+     *
+     * @example
+     * ```ts
+     * // Clone by entity class + where + overrides
+     * const cloned = await em.clone(Author, { id: 1 }, { email: 'new@email.com' });
+     *
+     * // Pure clone (all non-PK fields copied)
+     * const cloned = await em.clone(Author, { id: 1 });
+     *
+     * // Clone a loaded entity
+     * const author = await em.findOneOrFail(Author, 1);
+     * const cloned = await em.clone(author, { email: 'new@email.com' });
+     * ```
+     */
+    clone<Entity extends object>(entityNameOrEntity: EntityName<Entity> | Entity, whereOrOverrides?: FilterQuery<NoInfer<Entity>> | EntityData<Entity>, overridesOrOptions?: EntityData<Entity> | NativeInsertUpdateOptions<Entity>, options?: NativeInsertUpdateOptions<Entity>): Promise<Entity>;
     /**
      * Fires native multi-insert query. Calling this has no side effects on the context (identity map).
      */

package/EntityManager.js

@@ -1211,6 +1211,54 @@ export class EntityManager {
         });
         return res.insertId;
     }
+    /**
+     * Clones rows matching the condition at the database level via INSERT...SELECT.
+     * Automatically excludes auto-increment PKs, generated columns, and resets version properties.
+     * Returns the cloned entity, registered in the identity map.
+     *
+     * @example
+     * ```ts
+     * // Clone by entity class + where + overrides
+     * const cloned = await em.clone(Author, { id: 1 }, { email: 'new@email.com' });
+     *
+     * // Pure clone (all non-PK fields copied)
+     * const cloned = await em.clone(Author, { id: 1 });
+     *
+     * // Clone a loaded entity
+     * const author = await em.findOneOrFail(Author, 1);
+     * const cloned = await em.clone(author, { email: 'new@email.com' });
+     * ```
+     */
+    async clone(entityNameOrEntity, whereOrOverrides, overridesOrOptions, options) {
+        const em = this.getContext(false);
+        let entityName;
+        let where;
+        let overrides;
+        if (Utils.isEntity(entityNameOrEntity)) {
+            // clone(entity, overrides?, options?)
+            entityName = entityNameOrEntity.constructor;
+            where = helper(entityNameOrEntity).getPrimaryKey();
+            overrides = whereOrOverrides;
+            options = overridesOrOptions;
+        }
+        else {
+            // clone(EntityClass, where, overrides?, options?)
+            entityName = entityNameOrEntity;
+            where = whereOrOverrides;
+            overrides = overridesOrOptions;
+        }
+        options ??= {};
+        em.prepareOptions(options);
+        const meta = em.metadata.get(entityName);
+        const res = await em.driver.nativeClone(entityName, where, overrides, {
+            ctx: em.#transactionContext,
+            ...options,
+        });
+        const pk = res.insertId ?? res.row?.[meta.primaryKeys[0]];
+        return em.findOneOrFail(entityName, pk, {
+            schema: options.schema,
+        });
+    }
     /**
      * Fires native multi-insert query. Calling this has no side effects on the context (identity map).
      */

package/drivers/DatabaseDriver.d.ts

@@ -28,6 +28,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     abstract nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     abstract nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    nativeClone<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, overrides?: EntityData<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
     /** Creates a new EntityManager instance bound to this driver. */
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];

package/drivers/DatabaseDriver.js

@@ -27,6 +27,9 @@ export class DatabaseDriver {
     async nativeUpdateMany(entityName, where, data, options) {
         throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
     }
+    async nativeClone(entityName, where, overrides, options) {
+        throw new Error(`${this.constructor.name} does not support nativeClone`);
+    }
     /** Creates a new EntityManager instance bound to this driver. */
     createEntityManager(useContext) {
         const EntityManagerClass = this.config.get('entityManager', EntityManager);

package/drivers/IDatabaseDriver.d.ts

@@ -52,6 +52,11 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
     nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     /** Deletes rows matching the given condition. */
     nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
+    /**
+     * Clones rows matching the condition at the database level via INSERT...SELECT.
+     * Automatically excludes auto-increment PKs, generated columns, and resets version properties.
+     */
+    nativeClone<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, overrides?: EntityData<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     /** Persists changes to M:N collections (inserts/deletes pivot table rows). */
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     /** Counts entities matching the given condition. */

package/entity/defineEntity.d.ts

@@ -127,9 +127,13 @@ export interface PropertyChain<Value, Options> {
     pivotEntity(pivotEntity: () => EntityName): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     fixedOrder(fixedOrder?: boolean): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     fixedOrderColumn(fixedOrderColumn: string): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
-    array(): HasKind<Options, 'embedded' | 'enum'> extends true ? PropertyChain<Value, Omit<Options, 'array'> & {
+    array(): Options extends {
+        kind: infer K extends string;
+    } ? K extends 'embedded' | 'enum' ? PropertyChain<Value, Omit<Options, 'array'> & {
         array: true;
-    }> : never;
+    }> : never : PropertyChain<Value, Omit<Options, 'array'> & {
+        array: true;
+    }>;
     prefix(prefix: string | boolean): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
     prefixMode(prefixMode: EmbeddedPrefixMode): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
     object(object?: boolean): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;

package/metadata/MetadataDiscovery.js

@@ -1646,7 +1646,14 @@ export class MetadataDiscovery {
                 return (!Type.getType(t[type]).ensureComparable(meta, prop) && (prop.type === t[type] || brand === type));
             });
             if (type) {
-                prop.type = type === 'datetime' ? 'Date' : type;
+                if (prop.array) {
+                    // built-in type + array: true — force-create instance for ArrayType wrapping
+                    prop.customType = new prop.type();
+                    prop.type = prop.customType.constructor.name;
+                }
+                else {
+                    prop.type = type === 'datetime' ? 'Date' : type;
+                }
             }
             else {
                 prop.customType = new prop.type();
@@ -1656,6 +1663,30 @@ export class MetadataDiscovery {
         if (simple) {
             return;
         }
+        if (prop.array &&
+            prop.customType &&
+            !(prop.customType instanceof t.array) &&
+            !(prop.customType instanceof t.enumArray) &&
+            prop.kind === ReferenceKind.SCALAR) {
+            const innerType = prop.customType;
+            innerType.platform = this.#platform;
+            innerType.meta = meta;
+            innerType.prop = prop;
+            if (!prop.columnTypes) {
+                const arrayDecl = this.#platform.getArrayDeclarationSQL();
+                if (arrayDecl.endsWith('[]')) {
+                    // native array support (e.g. postgres) — use inner type's column type with [] suffix
+                    prop.columnTypes = [innerType.getColumnType(prop, this.#platform) + '[]'];
+                }
+                else {
+                    // non-native (e.g. mysql, sqlite) — store as text/clob
+                    prop.columnTypes = [arrayDecl];
+                }
+            }
+            const platform = this.#platform;
+            prop.customType = new t.array(v => innerType.convertToJSValue(v, platform), v => innerType.convertToDatabaseValue(v, platform));
+            prop.type = prop.customType.constructor.name;
+        }
         if (!prop.customType && ['json', 'jsonb'].includes(prop.type?.toLowerCase())) {
             prop.customType = new t.json();
         }

package/metadata/types.d.ts

@@ -202,6 +202,12 @@ export interface PropertyOptions<Owner> {
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
     lazy?: boolean;
+    /**
+     * Marks this property as an array. When used with a custom type, the type is automatically
+     * wrapped in an `ArrayType` that delegates element conversion to the inner type.
+     * The column type is inferred as `innerType[]` (e.g. `int[]`, `time[]`).
+     */
+    array?: boolean;
     /**
      * Set true to define entity's unique primary key identifier.
      * Alias for `@PrimaryKey()` decorator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.0-dev.2",
+  "version": "7.1.0-dev.4",
   "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.",
   "keywords": [
     "data-mapper",

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.0-dev.2';
+    static #ORM_VERSION = '7.1.0-dev.4';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */