@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/utils/EntityComparator.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityComparator = void 0;
-const clone_1 = require("./clone");
-const enums_1 = require("../enums");
-const Utils_1 = require("./Utils");
-const JsonType_1 = require("../types/JsonType");
-const RawQueryFragment_1 = require("./RawQueryFragment");
-class EntityComparator {
+import { clone } from './clone.js';
+import { ReferenceKind } from '../enums.js';
+import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
+import { JsonType } from '../types/JsonType.js';
+import { RawQueryFragment } from './RawQueryFragment.js';
+export class EntityComparator {
     metadata;
     platform;
     comparators = new Map();
@@ -25,11 +22,11 @@ class EntityComparator {
      */
     diffEntities(entityName, a, b) {
         const comparator = this.getEntityComparator(entityName);
-        return Utils_1.Utils.callCompiledFunction(comparator, a, b);
+        return Utils.callCompiledFunction(comparator, a, b);
     }
     matching(entityName, a, b) {
         const diff = this.diffEntities(entityName, a, b);
-        return Utils_1.Utils.getObjectKeysSize(diff) === 0;
+        return Utils.getObjectKeysSize(diff) === 0;
     }
     /**
      * Removes ORM specific code from entities and prepares it for serializing. Used before change set computation.
@@ -37,21 +34,21 @@ class EntityComparator {
      */
     prepareEntity(entity) {
         const generator = this.getSnapshotGenerator(entity.constructor.name);
-        return Utils_1.Utils.callCompiledFunction(generator, entity);
+        return Utils.callCompiledFunction(generator, entity);
     }
     /**
      * Maps database columns to properties.
      */
     mapResult(entityName, result) {
         const mapper = this.getResultMapper(entityName);
-        return Utils_1.Utils.callCompiledFunction(mapper, result);
+        return Utils.callCompiledFunction(mapper, result);
     }
     /**
      * @internal Highly performance-sensitive method.
      */
     getPkGetter(meta) {
         const exists = this.pkGetters.get(meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (exists) {
             return exists;
         }
@@ -60,7 +57,7 @@ class EntityComparator {
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const cond = {`);
             meta.primaryKeys.forEach(pk => {
-                if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+                if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getPrimaryKey() : entity${this.wrap(pk)},`);
                 }
                 else {
@@ -73,7 +70,7 @@ class EntityComparator {
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+            if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
                 lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
                 if (meta.properties[pk].targetMeta.compositePK) {
@@ -92,7 +89,7 @@ class EntityComparator {
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils_1.Utils.createFunction(context, code);
+        const pkSerializer = Utils.createFunction(context, code);
         this.pkGetters.set(meta.className, pkSerializer);
         return pkSerializer;
     }
@@ -101,7 +98,7 @@ class EntityComparator {
      */
     getPkGetterConverted(meta) {
         const exists = this.pkGettersConverted.get(meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (exists) {
             return exists;
         }
@@ -110,7 +107,7 @@ class EntityComparator {
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const cond = {`);
             meta.primaryKeys.forEach(pk => {
-                if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+                if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    ${pk}: (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getPrimaryKey(true) : entity${this.wrap(pk)},`);
                 }
                 else {
@@ -129,7 +126,7 @@ class EntityComparator {
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+            if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getPrimaryKey(true);`);
             }
             if (meta.properties[pk].customType) {
@@ -142,7 +139,7 @@ class EntityComparator {
         }
         const code = `// compiled pk getter (with converted custom types) for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils_1.Utils.createFunction(context, code);
+        const pkSerializer = Utils.createFunction(context, code);
         this.pkGettersConverted.set(meta.className, pkSerializer);
         return pkSerializer;
     }
@@ -151,17 +148,17 @@ class EntityComparator {
      */
     getPkSerializer(meta) {
         const exists = this.pkSerializers.get(meta.className);
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (exists) {
             return exists;
         }
         const lines = [];
         const context = new Map();
-        context.set('getCompositeKeyValue', (val) => Utils_1.Utils.flatten(Utils_1.Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.platform)));
+        context.set('getCompositeKeyValue', (val) => Utils.flatten(Utils.getCompositeKeyValue(val, meta, 'convertToDatabaseValue', this.platform)));
         if (meta.primaryKeys.length > 1) {
             lines.push(`  const pks = entity.__helper.__pk ? getCompositeKeyValue(entity.__helper.__pk) : [`);
             meta.primaryKeys.forEach(pk => {
-                if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+                if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                     lines.push(`    (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) ? entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey() : entity${this.wrap(pk)},`);
                 }
                 else {
@@ -169,11 +166,11 @@ class EntityComparator {
                 }
             });
             lines.push(`  ];`);
-            lines.push(`  return pks.join('${Utils_1.Utils.PK_SEPARATOR}');`);
+            lines.push(`  return pks.join('${Utils.PK_SEPARATOR}');`);
         }
         else {
             const pk = meta.primaryKeys[0];
-            if (meta.properties[pk].kind !== enums_1.ReferenceKind.SCALAR) {
+            if (meta.properties[pk].kind !== ReferenceKind.SCALAR) {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) return entity${this.wrap(pk)}.__helper.getSerializedPrimaryKey();`);
             }
             const serializedPrimaryKey = meta.props.find(p => p.serializedPrimaryKey);
@@ -184,7 +181,7 @@ class EntityComparator {
         }
         const code = `// compiled pk serializer for entity ${meta.className}\n`
             + `return function(entity) {\n${lines.join('\n')}\n}`;
-        const pkSerializer = Utils_1.Utils.createFunction(context, code);
+        const pkSerializer = Utils.createFunction(context, code);
         this.pkSerializers.set(meta.className, pkSerializer);
         return pkSerializer;
     }
@@ -199,7 +196,7 @@ class EntityComparator {
         const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
-        context.set('clone', clone_1.clone);
+        context.set('clone', clone);
         context.set('cloneEmbeddable', (o) => this.platform.cloneEmbeddable(o)); // do not clone prototypes
         if (meta.discriminatorValue) {
             lines.push(`  ret${this.wrap(meta.root.discriminatorColumn)} = '${meta.discriminatorValue}'`);
@@ -209,11 +206,11 @@ class EntityComparator {
         meta.comparableProps
             .filter(prop => {
             const root = getRootProperty(prop);
-            return prop === root || root.kind !== enums_1.ReferenceKind.EMBEDDED;
+            return prop === root || root.kind !== ReferenceKind.EMBEDDED;
         })
             .forEach(prop => lines.push(this.getPropertySnapshot(meta, prop, context, this.wrap(prop.name), this.wrap(prop.name), [prop.name])));
         const code = `return function(entity) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const snapshotGenerator = Utils_1.Utils.createFunction(context, code);
+        const snapshotGenerator = Utils.createFunction(context, code);
         this.snapshotGenerators.set(entityName, snapshotGenerator);
         return snapshotGenerator;
     }
@@ -318,10 +315,10 @@ class EntityComparator {
                 lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                 lines.push(`  }`);
             }
-            else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
+            else if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
                 const idx = this.tmpIndex++;
                 context.set(`mapEmbeddedResult_${idx}`, (data) => {
-                    const item = (0, Utils_1.parseJsonSafe)(data);
+                    const item = parseJsonSafe(data);
                     if (Array.isArray(item)) {
                         return item.map(row => row == null ? row : this.getResultMapper(prop.type)(row));
                     }
@@ -332,7 +329,7 @@ class EntityComparator {
                 lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
                 lines.push(`  }`);
             }
-            else if (prop.kind !== enums_1.ReferenceKind.EMBEDDED) {
+            else if (prop.kind !== ReferenceKind.EMBEDDED) {
                 lines.push(`  if (typeof ${this.propName(prop.fieldNames[0])} !== 'undefined') {`);
                 lines.push(`    ret${this.wrap(prop.name)} = ${this.propName(prop.fieldNames[0])};`);
                 lines.push(`    ${this.propName(prop.fieldNames[0], 'mapped')} = true;`);
@@ -342,7 +339,7 @@ class EntityComparator {
         lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k]) ret[k] = result[k]; }`);
         const code = `// compiled mapper for entity ${meta.className}\n`
             + `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
-        const resultMapper = Utils_1.Utils.createFunction(context, code);
+        const resultMapper = Utils.createFunction(context, code);
         this.mappers.set(entityName, resultMapper);
         return resultMapper;
     }
@@ -408,7 +405,7 @@ class EntityComparator {
             if (!childProp.customType) {
                 return false;
             }
-            if (childProp.customType instanceof JsonType_1.JsonType) {
+            if (childProp.customType instanceof JsonType) {
                 return !prop.object;
             }
             return true;
@@ -419,10 +416,10 @@ class EntityComparator {
             const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
             const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
             const childCond = `typeof entity${childEntityKey} !== 'undefined'`;
-            if (childProp.kind === enums_1.ReferenceKind.EMBEDDED) {
+            if (childProp.kind === ReferenceKind.EMBEDDED) {
                 return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level + 1, prop.object);
             }
-            if (childProp.kind !== enums_1.ReferenceKind.SCALAR) {
+            if (childProp.kind !== ReferenceKind.SCALAR) {
                 return this.getPropertySnapshot(meta, childProp, context, childDataKey, childEntityKey, [...path, childProp.embedded[1]], level, prop.object)
                     .split('\n').map(l => padding + l).join('\n');
             }
@@ -443,8 +440,8 @@ class EntityComparator {
     registerCustomType(prop, context) {
         const convertorKey = this.safeKey(prop.name);
         context.set(`convertToDatabaseValue_${convertorKey}`, (val) => {
-            /* istanbul ignore if */
-            if (RawQueryFragment_1.RawQueryFragment.isKnownFragment(val)) {
+            /* v8 ignore next 3 */
+            if (RawQueryFragment.isKnownFragment(val)) {
                 return val;
             }
             return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
@@ -457,13 +454,13 @@ class EntityComparator {
         if (['number', 'string', 'boolean'].includes(prop.type.toLowerCase())) {
             return ret + `    ret${dataKey} = entity${entityKey}${unwrap};\n  }\n`;
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind === ReferenceKind.EMBEDDED) {
             if (prop.array) {
                 return this.getEmbeddedArrayPropertySnapshot(meta, prop, context, level, path, dataKey) + '\n';
             }
             return this.getEmbeddedPropertySnapshot(meta, prop, context, level, path, dataKey, object) + '\n';
         }
-        if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE) {
+        if (prop.kind === ReferenceKind.ONE_TO_ONE || prop.kind === ReferenceKind.MANY_TO_ONE) {
             if (prop.mapToPk) {
                 if (prop.customType) {
                     const convertorKey = this.registerCustomType(prop, context);
@@ -475,7 +472,7 @@ class EntityComparator {
             }
             else {
                 const toArray = (val) => {
-                    if (Utils_1.Utils.isPlainObject(val)) {
+                    if (Utils.isPlainObject(val)) {
                         return Object.values(val).map(v => toArray(v));
                     }
                     return val;
@@ -513,17 +510,17 @@ class EntityComparator {
         const meta = this.metadata.find(entityName);
         const lines = [];
         const context = new Map();
-        context.set('compareArrays', Utils_1.compareArrays);
-        context.set('compareBooleans', Utils_1.compareBooleans);
-        context.set('compareBuffers', Utils_1.compareBuffers);
-        context.set('compareObjects', Utils_1.compareObjects);
-        context.set('equals', Utils_1.equals);
+        context.set('compareArrays', compareArrays);
+        context.set('compareBooleans', compareBooleans);
+        context.set('compareBuffers', compareBuffers);
+        context.set('compareObjects', compareObjects);
+        context.set('equals', equals);
         meta.comparableProps.forEach(prop => {
             lines.push(this.getPropertyComparator(prop, context));
         });
         const code = `// compiled comparator for entity ${meta.className}\n`
             + `return function(last, current) {\n  const diff = {};\n${lines.join('\n')}\n  return diff;\n}`;
-        const comparator = Utils_1.Utils.createFunction(context, code);
+        const comparator = Utils.createFunction(context, code);
         this.comparators.set(entityName, comparator);
         return comparator;
     }
@@ -537,7 +534,7 @@ class EntityComparator {
     }
     getPropertyComparator(prop, context) {
         let type = prop.type.toLowerCase();
-        if (prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED) {
             const meta2 = this.metadata.find(prop.type);
             if (meta2.primaryKeys.length > 1) {
                 type = 'array';
@@ -595,10 +592,9 @@ class EntityComparator {
      */
     static isComparable(prop, root) {
         const virtual = prop.persist === false || prop.generated;
-        const inverse = prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
+        const inverse = prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
         const discriminator = prop.name === root.discriminatorColumn;
-        const collection = prop.kind === enums_1.ReferenceKind.ONE_TO_MANY || prop.kind === enums_1.ReferenceKind.MANY_TO_MANY;
+        const collection = prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY;
         return !virtual && !collection && !inverse && !discriminator && !prop.version;
     }
 }
-exports.EntityComparator = EntityComparator;

package/utils/NullHighlighter.d.ts

@@ -1,4 +1,4 @@
-import type { Highlighter } from '../typings';
+import type { Highlighter } from '../typings.js';
 export declare class NullHighlighter implements Highlighter {
     highlight(text: string): string;
 }

package/utils/NullHighlighter.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NullHighlighter = void 0;
-class NullHighlighter {
+export class NullHighlighter {
     highlight(text) {
         return text;
     }
 }
-exports.NullHighlighter = NullHighlighter;

package/utils/QueryHelper.d.ts

@@ -1,6 +1,6 @@
-import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings';
-import type { Platform } from '../platforms';
-import type { MetadataStorage } from '../metadata/MetadataStorage';
+import type { Dictionary, EntityMetadata, EntityProperty, FilterDef, FilterQuery } from '../typings.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
     static processParams(params: unknown): any;

package/utils/QueryHelper.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryHelper = void 0;
-const Reference_1 = require("../entity/Reference");
-const Utils_1 = require("./Utils");
-const enums_1 = require("../enums");
-const JsonType_1 = require("../types/JsonType");
-const wrap_1 = require("../entity/wrap");
-const RawQueryFragment_1 = require("./RawQueryFragment");
-class QueryHelper {
+import { Reference } from '../entity/Reference.js';
+import { Utils } from './Utils.js';
+import { GroupOperator, ReferenceKind } from '../enums.js';
+import { JsonType } from '../types/JsonType.js';
+import { helper } from '../entity/wrap.js';
+import { RawQueryFragment, isRaw } from './RawQueryFragment.js';
+export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     static processParams(params) {
-        if (Reference_1.Reference.isReference(params)) {
+        if (Reference.isReference(params)) {
             params = params.unwrap();
         }
-        if (Utils_1.Utils.isEntity(params)) {
-            if ((0, wrap_1.helper)(params).__meta.compositePK) {
-                return (0, wrap_1.helper)(params).__primaryKeys;
+        if (Utils.isEntity(params)) {
+            if (helper(params).__meta.compositePK) {
+                return helper(params).__primaryKeys;
             }
-            return (0, wrap_1.helper)(params).getPrimaryKey();
+            return helper(params).getPrimaryKey();
         }
         if (params === undefined) {
             return null;
@@ -25,13 +22,13 @@ class QueryHelper {
         if (Array.isArray(params)) {
             return params.map(item => QueryHelper.processParams(item));
         }
-        if (Utils_1.Utils.isPlainObject(params)) {
+        if (Utils.isPlainObject(params)) {
             QueryHelper.processObjectParams(params);
         }
         return params;
     }
     static processObjectParams(params = {}) {
-        Utils_1.Utils.keys(params).forEach(k => {
+        Utils.keys(params).forEach(k => {
             params[k] = QueryHelper.processParams(params[k]);
         });
         return params;
@@ -40,19 +37,19 @@ class QueryHelper {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                    where[i] = Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
                 }
             });
         }
-        if (!Utils_1.Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType_1.JsonType)) {
+        if (!Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType)) {
             return false;
         }
-        if (meta.primaryKeys.every(pk => pk in where) && Utils_1.Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
-            return !!key && !enums_1.GroupOperator[key] && Object.keys(where).every(k => !Utils_1.Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
-                if (Utils_1.Utils.isOperator(v, false)) {
+        if (meta.primaryKeys.every(pk => pk in where) && Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
+            return !!key && !GroupOperator[key] && Object.keys(where).every(k => !Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
+                if (Utils.isOperator(v, false)) {
                     return false;
                 }
-                if (meta.properties[k].primary && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
+                if (meta.properties[k].primary && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
                     return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
                 }
                 return true;
@@ -61,7 +58,7 @@ class QueryHelper {
         Object.keys(where).forEach(k => {
             const meta2 = metadata.find(meta.properties[k]?.type) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
-                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+                where[k] = Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
             }
         });
         return false;
@@ -75,27 +72,27 @@ class QueryHelper {
             QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
         }
         if (platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
-            Utils_1.Utils.dropUndefinedProperties(where);
+            Utils.dropUndefinedProperties(where);
         }
         where = QueryHelper.processParams(where) ?? {};
-        /* istanbul ignore next */
-        if (!root && Utils_1.Utils.isPrimaryKey(where)) {
+        /* v8 ignore next 3 */
+        if (!root && Utils.isPrimaryKey(where)) {
             return where;
         }
-        if (meta && Utils_1.Utils.isPrimaryKey(where, meta.compositePK)) {
-            where = { [Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
+        if (meta && Utils.isPrimaryKey(where, meta.compositePK)) {
+            where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         if (Array.isArray(where) && root) {
-            const rootPrimaryKey = meta ? Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
+            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
             let cond = { [rootPrimaryKey]: { $in: where } };
             // @ts-ignore
             // detect tuple comparison, use `$or` in case the number of constituents don't match
-            if (meta && !where.every(c => Utils_1.Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils_1.Utils.isPrimaryKey(i))))) {
+            if (meta && !where.every(c => Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils.isPrimaryKey(i))))) {
                 cond = { $or: where };
             }
             return QueryHelper.processWhere({ ...options, where: cond, root: false });
         }
-        if (!Utils_1.Utils.isPlainObject(where)) {
+        if (!Utils.isPlainObject(where)) {
             return where;
         }
         return Object.keys(where).reduce((o, key) => {
@@ -103,34 +100,34 @@ class QueryHelper {
             const prop = this.findProperty(key, options);
             const keys = prop?.joinColumns?.length ?? 0;
             const composite = keys > 1;
-            if (Array.isArray(value) && value.length === 0 && RawQueryFragment_1.RawQueryFragment.isKnownFragment(key)) {
+            if (Array.isArray(value) && value.length === 0 && RawQueryFragment.isKnownFragment(key)) {
                 o[key] = value;
                 return o;
             }
-            if (key in enums_1.GroupOperator) {
+            if (key in GroupOperator) {
                 o[key] = value.map((sub) => QueryHelper.processWhere({ ...options, where: sub, root }));
                 return o;
             }
             // wrap top level operators (except platform allowed operators) with PK
-            if (Utils_1.Utils.isOperator(key) && root && meta && !platform.isAllowedTopLevelOperator(key)) {
-                const rootPrimaryKey = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+            if (Utils.isOperator(key) && root && meta && !platform.isAllowedTopLevelOperator(key)) {
+                const rootPrimaryKey = Utils.getPrimaryKeyHash(meta.primaryKeys);
                 o[rootPrimaryKey] = { [key]: QueryHelper.processWhere({ ...options, where: value, root: false }) };
                 return o;
             }
-            if (prop?.customType && convertCustomTypes && !(0, RawQueryFragment_1.isRaw)(value)) {
+            if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
-            const isJsonProperty = prop?.customType instanceof JsonType_1.JsonType && Utils_1.Utils.isPlainObject(value) && !(0, RawQueryFragment_1.isRaw)(value) && Object.keys(value)[0] !== '$eq';
+            const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
             if (isJsonProperty) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
-            if (Array.isArray(value) && !Utils_1.Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
+            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
                 // comparing single composite key - use $eq instead of $in
                 const op = composite && !value.every(v => Array.isArray(v)) ? '$eq' : '$in';
                 o[key] = { [op]: value };
                 return o;
             }
-            if (Utils_1.Utils.isPlainObject(value)) {
+            if (Utils.isPlainObject(value)) {
                 o[key] = QueryHelper.processWhere({
                     ...options,
                     where: value,
@@ -152,7 +149,7 @@ class QueryHelper {
         if (Array.isArray(options)) {
             options.forEach(filter => opts[filter] = true);
         }
-        else if (Utils_1.Utils.isPlainObject(options)) {
+        else if (Utils.isPlainObject(options)) {
             Object.keys(options).forEach(filter => opts[filter] = options[filter]);
         }
         return Object.keys(filters)
@@ -172,9 +169,9 @@ class QueryHelper {
         return filter.default || filterName in options;
     }
     static processCustomType(prop, cond, platform, key, fromQuery) {
-        if (Utils_1.Utils.isPlainObject(cond)) {
-            return Utils_1.Utils.keys(cond).reduce((o, k) => {
-                if (Utils_1.Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
+        if (Utils.isPlainObject(cond)) {
+            return Utils.keys(cond).reduce((o, k) => {
+                if (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
                     o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
                 }
                 else {
@@ -183,15 +180,15 @@ class QueryHelper {
                 return o;
             }, {});
         }
-        if (key && Utils_1.Utils.isJsonKeyOperator(key)) {
+        if (key && Utils.isJsonKeyOperator(key)) {
             return Array.isArray(cond)
                 ? platform.marshallArray(cond)
                 : cond;
         }
-        if (Array.isArray(cond) && !(key && Utils_1.Utils.isArrayOperator(key))) {
+        if (Array.isArray(cond) && !(key && Utils.isArrayOperator(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
         }
-        if ((0, RawQueryFragment_1.isRaw)(cond)) {
+        if (isRaw(cond)) {
             return cond;
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
@@ -200,8 +197,8 @@ class QueryHelper {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }
     static processJsonCondition(o, value, path, platform, alias) {
-        if (Utils_1.Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils_1.Utils.isOperator(k))) {
-            Utils_1.Utils.keys(value).forEach(k => {
+        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
+            Utils.keys(value).forEach(k => {
                 this.processJsonCondition(o, value[k], [...path, k], platform, alias);
             });
             return o;
@@ -219,7 +216,7 @@ class QueryHelper {
         if (Array.isArray(value)) {
             return typeof value[0];
         }
-        if (Utils_1.Utils.isPlainObject(value) && Object.keys(value).every(k => Utils_1.Utils.isOperator(k))) {
+        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
             return this.getValueType(Object.values(value)[0]);
         }
         return typeof value;
@@ -233,4 +230,3 @@ class QueryHelper {
         return meta?.properties[propName];
     }
 }
-exports.QueryHelper = QueryHelper;

package/utils/RawQueryFragment.d.ts

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util';
-import type { AnyString, Dictionary, EntityKey } from '../typings';
+import type { AnyString, Dictionary, EntityKey } from '../typings.js';
 export declare class RawQueryFragment {
     #private;
     readonly sql: string;