@mikro-orm/entity-generator 7.0.0-dev.24 → 7.0.0-dev.241

package/SourceFile.js

@@ -1,19 +1,20 @@
-import { Cascade, Config, DecimalType, ReferenceKind, SCALAR_TYPES, UnknownType, Utils, } from '@mikro-orm/core';
+import { Cascade, Config, DecimalType, ReferenceKind, SCALAR_TYPES, UnknownType, Utils, inspect, } from '@mikro-orm/core';
 import { parse, relative } from 'node:path';
-import { inspect } from 'node:util';
 import { POSSIBLE_TYPE_IMPORTS } from './CoreImportsHelper.js';
 /**
  * @see https://github.com/tc39/proposal-regexp-unicode-property-escapes#other-examples
  */
 export const identifierRegex = /^(?:[$_\p{ID_Start}])(?:[$\u200C\u200D\p{ID_Continue}])*$/u;
-const primitivesAndLibs = [...SCALAR_TYPES, 'bigint', 'Uint8Array', 'unknown', 'object', 'any'];
+const primitivesAndLibs = [...SCALAR_TYPES, 'unknown', 'object', 'any'];
 export class SourceFile {
     meta;
     namingStrategy;
     platform;
     options;
     coreImports = new Set();
+    decoratorImports = new Set();
     entityImports = new Set();
+    enumImports = new Map();
     constructor(meta, namingStrategy, platform, options) {
         this.meta = meta;
         this.namingStrategy = namingStrategy;
@@ -25,24 +26,24 @@ export class SourceFile {
         if (this.meta.embeddable || this.meta.collection) {
             if (this.meta.embeddable) {
                 const options = this.getEmbeddableDeclOptions();
-                ret += `@${this.referenceCoreImport('Embeddable')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
+                ret += `@${this.referenceDecoratorImport('Embeddable')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
             }
             else {
                 const options = this.getEntityDeclOptions();
-                ret += `@${this.referenceCoreImport('Entity')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
+                ret += `@${this.referenceDecoratorImport('Entity')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
             }
         }
         for (const index of this.meta.indexes) {
             if (index.properties?.length === 1 && typeof this.meta.properties[index.properties[0]] !== 'undefined') {
                 continue;
             }
-            ret += `@${this.referenceCoreImport('Index')}(${this.serializeObject(this.getIndexOptions(index))})\n`;
+            ret += `@${this.referenceDecoratorImport('Index')}(${this.serializeObject(this.getIndexOptions(index))})\n`;
         }
         for (const index of this.meta.uniques) {
             if (index.properties?.length === 1 && typeof this.meta.properties[index.properties[0]] !== 'undefined') {
                 continue;
             }
-            ret += `@${this.referenceCoreImport('Unique')}(${this.serializeObject(this.getUniqueOptions(index))})\n`;
+            ret += `@${this.referenceDecoratorImport('Unique')}(${this.serializeObject(this.getUniqueOptions(index))})\n`;
         }
         let classHead = '';
         if (this.meta.className === this.options.customBaseEntityName) {
@@ -65,7 +66,10 @@ export class SourceFile {
             classBody += definition;
             classBody += '\n';
             if (prop.enum) {
-                enumDefinitions.push(this.getEnumClassDefinition(prop, 2));
+                const def = this.getEnumClassDefinition(prop, 2);
+                if (def.length) {
+                    enumDefinitions.push(def);
+                }
             }
             if (prop.eager) {
                 eagerProperties.push(prop);
@@ -94,6 +98,30 @@ export class SourceFile {
         }
         return ret;
     }
+    /**
+     * Convert index column options to quoted output format.
+     */
+    getColumnOptions(columns) {
+        if (!columns?.length) {
+            return undefined;
+        }
+        return columns.map(col => {
+            const colOpt = { name: this.quote(col.name) };
+            if (col.sort) {
+                colOpt.sort = this.quote(col.sort.toUpperCase());
+            }
+            if (col.nulls) {
+                colOpt.nulls = this.quote(col.nulls.toUpperCase());
+            }
+            if (col.length != null) {
+                colOpt.length = col.length;
+            }
+            if (col.collation) {
+                colOpt.collation = this.quote(col.collation);
+            }
+            return colOpt;
+        });
+    }
     getIndexOptions(index, isAtEntityLevel = true) {
         const indexOpt = {};
         if (typeof index.name === 'string') {
@@ -108,6 +136,30 @@ export class SourceFile {
         if (isAtEntityLevel && index.properties) {
             indexOpt.properties = Utils.asArray(index.properties).map(prop => this.quote('' + prop));
         }
+        // Index type (e.g., 'fulltext', 'spatial', 'btree', 'hash')
+        if (index.type) {
+            indexOpt.type = this.quote(index.type);
+        }
+        // Advanced index options
+        const columns = this.getColumnOptions(index.columns);
+        if (columns) {
+            indexOpt.columns = columns;
+        }
+        if (index.include) {
+            indexOpt.include = Utils.asArray(index.include).map(prop => this.quote('' + prop));
+        }
+        if (index.fillFactor != null) {
+            indexOpt.fillFactor = index.fillFactor;
+        }
+        if (index.invisible) {
+            indexOpt.invisible = true;
+        }
+        if (index.disabled) {
+            indexOpt.disabled = true;
+        }
+        if (index.clustered) {
+            indexOpt.clustered = true;
+        }
         return indexOpt;
     }
     getUniqueOptions(index, isAtEntityLevel = true) {
@@ -127,6 +179,19 @@ export class SourceFile {
         if (index.deferMode) {
             uniqueOpt.deferMode = `${this.referenceCoreImport('DeferMode')}.INITIALLY_${index.deferMode.toUpperCase()}`;
         }
+        const columns = this.getColumnOptions(index.columns);
+        if (columns) {
+            uniqueOpt.columns = columns;
+        }
+        if (index.include) {
+            uniqueOpt.include = Utils.asArray(index.include).map(prop => this.quote('' + prop));
+        }
+        if (index.fillFactor != null) {
+            uniqueOpt.fillFactor = index.fillFactor;
+        }
+        if (index.disabled) {
+            uniqueOpt.disabled = true;
+        }
         return uniqueOpt;
     }
     generateImports() {
@@ -141,37 +206,61 @@ export class SourceFile {
                 return ret;
             }).join(', '))} } from '@mikro-orm/core';`);
         }
+        if (this.decoratorImports.size > 0) {
+            const type = this.options.decorators;
+            imports.add(`import { ${([...this.decoratorImports].sort().map(t => {
+                let ret = t;
+                if (this.options.coreImportsPrefix) {
+                    const resolvedIdentifier = `${this.options.coreImportsPrefix}${t}`;
+                    ret += ` as ${resolvedIdentifier}`;
+                }
+                return ret;
+            }).join(', '))} } from '@mikro-orm/decorators/${type}';`);
+        }
         const extension = this.options.esmImport ? '.js' : '';
         const { dir, base } = parse(`${this.options.path ?? '.'}/${this.getBaseName()}`);
         const basePath = relative(dir, this.options.path ?? '.') || '.';
         (this.options.extraImports?.(basePath, base) ?? []).forEach(v => this.entityImports.add(v));
         const entityImports = [...this.entityImports].filter(e => e !== this.meta.className);
-        entityImports.sort().forEach(entity => {
+        const importMap = new Map();
+        for (const entity of entityImports) {
             const file = this.options.onImport?.(entity, basePath, extension, base) ?? {
                 path: `${basePath}/${this.options.fileName(entity)}${extension}`,
                 name: entity,
             };
             if (file.path === '') {
                 if (file.name === '') {
-                    return;
+                    continue;
                 }
-                imports.add(`import ${this.quote(file.name)};`);
-                return;
+                importMap.set(file.path, `import ${this.quote(file.name)};`);
+                continue;
             }
             if (file.name === '') {
-                imports.add(`import * as ${entity} from ${this.quote(file.path)};`);
-                return;
+                importMap.set(file.path, `import * as ${entity} from ${this.quote(file.path)};`);
+                continue;
             }
             if (file.name === 'default') {
-                imports.add(`import ${entity} from ${this.quote(file.path)};`);
-                return;
+                importMap.set(file.path, `import ${entity} from ${this.quote(file.path)};`);
+                continue;
             }
             if (file.name === entity) {
-                imports.add(`import { ${entity} } from ${this.quote(file.path)};`);
-                return;
+                importMap.set(file.path, `import { ${entity} } from ${this.quote(file.path)};`);
+                continue;
             }
-            imports.add(`import { ${identifierRegex.test(file.name) ? file.name : this.quote(file.name)} as ${entity} } from ${this.quote(file.path)};`);
-        });
+            importMap.set(file.path, `import { ${identifierRegex.test(file.name) ? file.name : this.quote(file.name)} as ${entity} } from ${this.quote(file.path)};`);
+        }
+        if (this.enumImports.size) {
+            for (const [name, exports] of this.enumImports.entries()) {
+                const file = this.options.onImport?.(name, basePath, extension, base) ?? {
+                    path: `${basePath}/${this.options.fileName(name)}${extension}`,
+                    name,
+                };
+                importMap.set(file.path, `import { ${exports.join(', ')} } from ${this.quote(file.path)};`);
+            }
+        }
+        for (const key of [...importMap.keys()].sort()) {
+            imports.add(importMap.get(key));
+        }
         return Array.from(imports.values()).join('\n');
     }
     getEntityClass(classBody) {
@@ -181,8 +270,8 @@ export class SourceFile {
         }
         ret += `class ${this.meta.className}`;
         if (this.meta.extends) {
-            this.entityImports.add(this.meta.extends);
-            ret += ` extends ${this.meta.extends}`;
+            this.entityImports.add(Utils.className(this.meta.extends));
+            ret += ` extends ${Utils.className(this.meta.extends)}`;
         }
         else if (this.options.useCoreBaseEntity) {
             ret += ` extends ${this.referenceCoreImport('BaseEntity')}`;
@@ -201,6 +290,7 @@ export class SourceFile {
     getPropertyDefinition(prop, padLeft) {
         const padding = ' '.repeat(padLeft);
         const propName = identifierRegex.test(prop.name) ? prop.name : this.quote(prop.name);
+        const enumMode = this.options.enumMode;
         let hiddenType = '';
         if (prop.hidden) {
             hiddenType += ` & ${this.referenceCoreImport('Hidden')}`;
@@ -218,7 +308,11 @@ export class SourceFile {
             : (() => {
                 if (isScalar) {
                     if (prop.enum) {
-                        return prop.runtimeType;
+                        const method = enumMode === 'ts-enum' ? 'getEnumClassName' : 'getEnumTypeName';
+                        if (prop.nativeEnumName) {
+                            return this.namingStrategy[method](prop.nativeEnumName, undefined, this.meta.schema);
+                        }
+                        return this.namingStrategy[method](prop.fieldNames[0], this.meta.collection, this.meta.schema);
                     }
                     breakdownOfIType = this.breakdownOfIType(prop);
                     if (typeof breakdownOfIType !== 'undefined') {
@@ -253,8 +347,14 @@ export class SourceFile {
             return `${padding}${ret};\n`;
         }
         if (prop.enum && typeof prop.default === 'string') {
+            if (enumMode === 'union-type') {
+                return `${padding}${ret} = ${this.quote(prop.default)};\n`;
+            }
+            const enumClassName = prop.nativeEnumName
+                ? this.namingStrategy.getEnumClassName(prop.nativeEnumName, undefined, this.meta.schema)
+                : this.namingStrategy.getEnumClassName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
             const enumVal = this.namingStrategy.enumValueToEnumProperty(prop.default, prop.fieldNames[0], this.meta.collection, this.meta.schema);
-            return `${padding}${ret} = ${propType}${identifierRegex.test(enumVal) ? `.${enumVal}` : `[${this.quote(enumVal)}]`};\n`;
+            return `${padding}${ret} = ${enumClassName}${identifierRegex.test(enumVal) ? `.${enumVal}` : `[${this.quote(enumVal)}]`};\n`;
         }
         if (prop.fieldNames?.length > 1) {
             // TODO: Composite FKs with default values require additions to default/defaultRaw that are not yet supported.
@@ -270,15 +370,51 @@ export class SourceFile {
         return `${padding}${ret} = ${prop.ref ? this.referenceCoreImport('ref') : this.referenceCoreImport('rel')}(${propType}, ${defaultVal});\n`;
     }
     getEnumClassDefinition(prop, padLeft) {
+        const enumMode = this.options.enumMode;
+        if (prop.nativeEnumName) {
+            const imports = [];
+            if (enumMode !== 'union-type') {
+                imports.push(prop.runtimeType);
+            }
+            if (!this.options.inferEntityType && enumMode !== 'ts-enum') {
+                const enumTypeName = this.namingStrategy.getEnumTypeName(prop.nativeEnumName, undefined, this.meta.schema);
+                imports.push(enumTypeName);
+            }
+            this.enumImports.set(prop.runtimeType, imports);
+            return '';
+        }
         const enumClassName = this.namingStrategy.getEnumClassName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
+        const enumTypeName = this.namingStrategy.getEnumTypeName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
         const padding = ' '.repeat(padLeft);
-        let ret = `export enum ${enumClassName} {\n`;
         const enumValues = prop.items;
+        if (enumMode === 'union-type') {
+            return `export type ${enumTypeName} = ${enumValues.map(item => this.quote(item)).join(' | ')};\n`;
+        }
+        let ret = '';
+        if (enumMode === 'dictionary') {
+            ret += `export const ${enumClassName} = {\n`;
+        }
+        else {
+            ret += `export enum ${enumClassName} {\n`;
+        }
         for (const enumValue of enumValues) {
             const enumName = this.namingStrategy.enumValueToEnumProperty(enumValue, prop.fieldNames[0], this.meta.collection, this.meta.schema);
-            ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${this.quote(enumValue)},\n`;
+            if (enumMode === 'dictionary') {
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)}: ${this.quote(enumValue)},\n`;
+            }
+            else {
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${this.quote(enumValue)},\n`;
+            }
+        }
+        if (enumMode === 'dictionary') {
+            ret += '} as const;\n';
+        }
+        else {
+            ret += '}\n';
+        }
+        if (enumMode === 'dictionary') {
+            ret += `\nexport type ${enumTypeName} = (typeof ${enumClassName})[keyof typeof ${enumClassName}];\n`;
         }
-        ret += '}\n';
         return ret;
     }
     serializeObject(options, wordwrap, spaces, level = 0) {
@@ -308,8 +444,8 @@ export class SourceFile {
     }
     getEntityDeclOptions() {
         const options = {};
-        if (this.meta.collection !== this.namingStrategy.classToTableName(this.meta.className)) {
-            options.tableName = this.quote(this.meta.collection);
+        if (this.meta.tableName !== this.namingStrategy.classToTableName(this.meta.className)) {
+            options.tableName = this.quote(this.meta.tableName);
         }
         if (this.meta.schema && this.meta.schema !== this.platform.getDefaultSchemaName()) {
             options.schema = this.quote(this.meta.schema);
@@ -318,7 +454,7 @@ export class SourceFile {
             options.expression = this.quote(this.meta.expression);
         }
         else if (typeof this.meta.expression === 'function') {
-            options.expression = `${this.meta.expression}`;
+            options.expression = this.meta.expression.toString();
         }
         if (this.meta.repositoryClass) {
             this.entityImports.add(this.meta.repositoryClass);
@@ -351,14 +487,14 @@ export class SourceFile {
         }
         if (this.meta.discriminatorMap) {
             options.discriminatorMap = Object.fromEntries(Object.entries(this.meta.discriminatorMap)
-                .map(([discriminatorValue, className]) => [discriminatorValue, this.quote(className)]));
+                .map(([discriminatorValue, cls]) => [discriminatorValue, this.quote(Utils.className(cls))]));
         }
         return options;
     }
     getPropertyDecorator(prop, padLeft) {
         const padding = ' '.repeat(padLeft);
         const options = {};
-        let decorator = `@${this.referenceCoreImport(this.getDecoratorType(prop))}`;
+        let decorator = `@${this.referenceDecoratorImport(this.getDecoratorType(prop))}`;
         if (prop.kind === ReferenceKind.MANY_TO_MANY) {
             this.getManyToManyDecoratorOptions(options, prop);
         }
@@ -379,7 +515,7 @@ export class SourceFile {
         decorator = [...indexes.sort(), decorator].map(d => padding + d).join('\n');
         const decoratorArgs = [];
         if (prop.formula) {
-            decoratorArgs.push(`${prop.formula}`);
+            decoratorArgs.push(prop.formula.toString());
         }
         if (Utils.hasObjectKeys(options)) {
             decoratorArgs.push(`${this.serializeObject(options)}`);
@@ -408,26 +544,26 @@ export class SourceFile {
         let propIndexIsNonTrivialIndex = false;
         const nonTrivialIndexes = this.meta.indexes.filter(i => i.properties?.length === 1 && i.properties[0] === prop.name);
         for (const i of nonTrivialIndexes) {
-            ret.push(`@${this.referenceCoreImport('Index')}(${this.serializeObject(this.getIndexOptions(i, false))})`);
+            ret.push(`@${this.referenceDecoratorImport('Index')}(${this.serializeObject(this.getIndexOptions(i, false))})`);
             if (prop.index === i.name) {
                 propIndexIsNonTrivialIndex = true;
                 delete options.index;
             }
         }
         if (prop.index && !options.index && !propIndexIsNonTrivialIndex) {
-            ret.push(`@${this.referenceCoreImport('Index')}(${typeof prop.index === 'string' ? `{ name: ${this.quote(prop.index)} }` : ''})`);
+            ret.push(`@${this.referenceDecoratorImport('Index')}(${typeof prop.index === 'string' ? `{ name: ${this.quote(prop.index)} }` : ''})`);
         }
         let propIndexIsNonTrivialUnique = false;
         const nonTrivialUnique = this.meta.uniques.filter(i => i.properties?.length === 1 && i.properties[0] === prop.name);
         for (const i of nonTrivialUnique) {
-            ret.push(`@${this.referenceCoreImport('Unique')}(${this.serializeObject(this.getUniqueOptions(i, false))})`);
+            ret.push(`@${this.referenceDecoratorImport('Unique')}(${this.serializeObject(this.getUniqueOptions(i, false))})`);
             if (prop.unique === i.name) {
                 propIndexIsNonTrivialUnique = true;
                 delete options.unique;
             }
         }
         if (prop.unique && !options.unique && !propIndexIsNonTrivialUnique) {
-            ret.push(`@${this.referenceCoreImport('Unique')}(${typeof prop.unique === 'string' ? `{ name: ${this.quote(prop.unique)} }` : ''})`);
+            ret.push(`@${this.referenceDecoratorImport('Unique')}(${typeof prop.unique === 'string' ? `{ name: ${this.quote(prop.unique)} }` : ''})`);
         }
         return ret;
     }
@@ -438,7 +574,7 @@ export class SourceFile {
         if (prop.primary && (prop.enum || !(typeof prop.kind === 'undefined' || prop.kind === ReferenceKind.SCALAR))) {
             options.primary = true;
         }
-        ['persist', 'hydrate', 'trackChanges']
+        ['persist', 'hydrate']
             .filter(key => prop[key] === false)
             .forEach(key => options[key] = false);
         ['onCreate', 'onUpdate', 'serializer']
@@ -537,12 +673,23 @@ export class SourceFile {
         this.propTypeBreakdowns.set(prop, r);
         return r;
     }
-    getScalarPropertyDecoratorOptions(options, prop) {
+    getScalarPropertyDecoratorOptions(options, prop, quote = true) {
         if (prop.fieldNames[0] !== this.namingStrategy.propertyToColumnName(prop.name)) {
             options.fieldName = this.quote(prop.fieldNames[0]);
         }
         if (prop.enum) {
-            options.items = `() => ${prop.runtimeType}`;
+            if (this.options.enumMode === 'union-type') {
+                options.items = `[${prop.items.map(item => this.quote(item)).join(', ')}]`;
+            }
+            else if (prop.nativeEnumName) {
+                const enumClassName = this.namingStrategy.getEnumClassName(prop.nativeEnumName, undefined, this.meta.schema);
+                options.items = `() => ${enumClassName}`;
+                options.nativeEnumName = this.quote(prop.nativeEnumName);
+            }
+            else {
+                const enumClassName = this.namingStrategy.getEnumClassName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
+                options.items = `() => ${enumClassName}`;
+            }
         }
         // For enum properties, we don't need a column type
         // or the property length or other information in the decorator.
@@ -571,7 +718,7 @@ export class SourceFile {
                     return ((useDefault && !hasUsableNullDefault) || (prop.optional && !prop.nullable));
                 })() // also when there is the "| Opt" type modifier (because reflect-metadata can't extract the base)
             ) {
-                options.type = this.quote(prop.type);
+                options.type = quote ? this.quote(prop.type) : prop.type;
             }
         }
         const columnTypeFromMappedRuntimeType = mappedRuntimeType.getColumnType({ ...prop, autoincrement: false }, this.platform);
@@ -598,7 +745,7 @@ export class SourceFile {
             assign('length');
         }
         // those are already included in the `columnType` in most cases, and when that option is present, they would be ignored anyway
-        /* v8 ignore next 4 */
+        /* v8 ignore next */
         if (mappedColumnType instanceof DecimalType && !options.columnType) {
             assign('precision');
             assign('scale');
@@ -632,12 +779,12 @@ export class SourceFile {
             options.mappedBy = this.quote(prop.mappedBy);
             return;
         }
-        if (prop.pivotTable !== this.namingStrategy.joinTableName(this.meta.collection, prop.type, prop.name)) {
+        if (prop.pivotTable !== this.namingStrategy.joinTableName(this.meta.collection, prop.type, prop.name, this.meta.tableName)) {
             options.pivotTable = this.quote(prop.pivotTable);
         }
-        if (prop.pivotEntity && prop.pivotEntity !== prop.pivotTable) {
-            this.entityImports.add(prop.pivotEntity);
-            options.pivotEntity = `() => ${prop.pivotEntity}`;
+        if (prop.pivotEntity && Utils.className(prop.pivotEntity) !== prop.pivotTable) {
+            this.entityImports.add(Utils.className(prop.pivotEntity));
+            options.pivotEntity = `() => ${Utils.className(prop.pivotEntity)}`;
         }
         if (prop.joinColumns.length === 1) {
             options.joinColumn = this.quote(prop.joinColumns[0]);
@@ -672,7 +819,7 @@ export class SourceFile {
         if (prop.array) {
             options.array = true;
         }
-        if (prop.object) {
+        if (prop.object && !prop.array) {
             options.object = true;
         }
         if (prop.prefix === false || typeof prop.prefix === 'string') {
@@ -705,10 +852,10 @@ export class SourceFile {
         if (prop.ownColumns && prop.ownColumns.length !== prop.fieldNames.length) {
             options.referencedColumnNames = prop.referencedColumnNames.map(fieldName => this.quote(fieldName));
         }
-        if (!['no action', 'restrict'].includes(prop.updateRule.toLowerCase())) {
+        if (prop.updateRule) {
             options.updateRule = this.quote(prop.updateRule);
         }
-        if (!['no action', 'restrict'].includes(prop.deleteRule.toLowerCase())) {
+        if (prop.deleteRule) {
             options.deleteRule = this.quote(prop.deleteRule);
         }
         if (prop.primary) {
@@ -755,4 +902,10 @@ export class SourceFile {
             ? `${this.options.coreImportsPrefix}${identifier}`
             : identifier;
     }
+    referenceDecoratorImport(identifier) {
+        this.decoratorImports.add(identifier);
+        return this.options.coreImportsPrefix
+            ? `${this.options.coreImportsPrefix}${identifier}`
+            : identifier;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/entity-generator",
   "type": "module",
-  "version": "7.0.0-dev.24",
+  "version": "7.0.0-dev.241",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -38,10 +38,10 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "node": ">= 22.17.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
@@ -50,12 +50,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "7.0.0-dev.24"
+    "@mikro-orm/sql": "7.0.0-dev.241"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.1"
+    "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.24"
+    "@mikro-orm/core": "7.0.0-dev.241"
   }
 }