@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/hydration/ObjectHydrator.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHydrator = void 0;
+const Hydrator_1 = require("./Hydrator");
+const Collection_1 = require("../entity/Collection");
+const Reference_1 = require("../entity/Reference");
+const Utils_1 = require("../utils/Utils");
+const enums_1 = require("../enums");
+class ObjectHydrator extends Hydrator_1.Hydrator {
+    hydrators = {
+        full: new Map(),
+        reference: new Map(),
+    };
+    tmpIndex = 0;
+    /**
+     * @inheritDoc
+     */
+    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema) {
+        const hydrate = this.getEntityHydrator(meta, type);
+        const running = this.running;
+        // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
+        // but we don't want that for new entities, their propagation should result in entity updates when flushing
+        this.running = !newEntity;
+        Utils_1.Utils.callCompiledFunction(hydrate, entity, data, factory, newEntity, convertCustomTypes, schema);
+        this.running = running;
+    }
+    /**
+     * @inheritDoc
+     */
+    hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema) {
+        const hydrate = this.getEntityHydrator(meta, 'reference');
+        const running = this.running;
+        this.running = true;
+        Utils_1.Utils.callCompiledFunction(hydrate, entity, data, factory, false, convertCustomTypes, schema);
+        this.running = running;
+    }
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getEntityHydrator(meta, type) {
+        const exists = this.hydrators[type].get(meta.className);
+        if (exists) {
+            return exists;
+        }
+        const lines = [];
+        const context = new Map();
+        const props = this.getProperties(meta, type);
+        context.set('isPrimaryKey', Utils_1.Utils.isPrimaryKey);
+        context.set('Collection', Collection_1.Collection);
+        context.set('Reference', Reference_1.Reference);
+        const hydrateScalar = (prop, object, path, dataKey) => {
+            const entityKey = path.map(k => this.wrap(k)).join('');
+            const tz = this.platform.getTimezone();
+            const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
+            const ret = [];
+            const idx = this.tmpIndex++;
+            const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
+            if (prop.ref) {
+                context.set('ScalarReference', Reference_1.ScalarReference);
+                ret.push(`  const oldValue_${idx} = entity${entityKey};`);
+            }
+            ret.push(`  if (data${dataKey} === null) {`);
+            ret.push(`    entity${entityKey} = ${nullVal};`);
+            ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
+            if (prop.customType) {
+                context.set(`convertToJSValue_${convertorKey}`, (val) => prop.customType.convertToJSValue(val, this.platform));
+                context.set(`convertToDatabaseValue_${convertorKey}`, (val) => prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'hydration' }));
+                ret.push(`    if (convertCustomTypes) {`, `      const value = convertToJSValue_${convertorKey}(data${dataKey});`);
+                if (prop.customType.ensureComparable(meta, prop)) {
+                    ret.push(`      data${dataKey} = convertToDatabaseValue_${convertorKey}(value);`);
+                }
+                ret.push(`      entity${entityKey} = value;`, `    } else {`, `      entity${entityKey} = data${dataKey};`, `    }`);
+            }
+            else if (prop.runtimeType === 'boolean') {
+                ret.push(`    entity${entityKey} = !!data${dataKey};`);
+            }
+            else if (prop.runtimeType === 'Date') {
+                ret.push(`    if (data${dataKey} instanceof Date) {`);
+                ret.push(`      entity${entityKey} = data${dataKey};`);
+                if (!tz || tz === 'local') {
+                    ret.push(`    } else {`);
+                    ret.push(`      entity${entityKey} = new Date(data${dataKey});`);
+                }
+                else {
+                    ret.push(`    } else if (typeof data${dataKey} === 'number' || data${dataKey}.includes('+')) {`);
+                    ret.push(`      entity${entityKey} = new Date(data${dataKey});`);
+                    ret.push(`    } else {`);
+                    ret.push(`      entity${entityKey} = new Date(data${dataKey} + '${tz}');`);
+                }
+                ret.push(`    }`);
+            }
+            else {
+                ret.push(`    entity${entityKey} = data${dataKey};`);
+            }
+            if (prop.ref) {
+                ret.push(`    const value = entity${entityKey};`);
+                ret.push(`    entity${entityKey} = oldValue_${idx} ?? new ScalarReference(value);`);
+                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`    entity${entityKey}.set(value);`);
+            }
+            ret.push(`  }`);
+            if (prop.ref) {
+                ret.push(`  if (!entity${entityKey}) {`);
+                ret.push(`    entity${entityKey} = new ScalarReference();`);
+                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`  }`);
+            }
+            return ret;
+        };
+        const hydrateToOne = (prop, dataKey, entityKey) => {
+            const ret = [];
+            const method = type === 'reference' ? 'createReference' : 'create';
+            const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
+            ret.push(`  if (data${dataKey} === null) {\n    entity${entityKey} = ${nullVal};`);
+            ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
+            ret.push(`    if (isPrimaryKey(data${dataKey}, true)) {`);
+            if (prop.ref) {
+                ret.push(`      entity${entityKey} = Reference.create(factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema }));`);
+            }
+            else {
+                ret.push(`      entity${entityKey} = factory.createReference('${prop.type}', data${dataKey}, { merge: true, convertCustomTypes, schema });`);
+            }
+            ret.push(`    } else if (data${dataKey} && typeof data${dataKey} === 'object') {`);
+            if (prop.ref) {
+                ret.push(`      entity${entityKey} = Reference.create(factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, schema }));`);
+            }
+            else {
+                ret.push(`      entity${entityKey} = factory.${method}('${prop.type}', data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, schema });`);
+            }
+            ret.push(`    }`);
+            ret.push(`  }`);
+            if (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE) {
+                const meta2 = this.metadata.get(prop.type);
+                const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
+                if (prop2 && !prop2.mapToPk) {
+                    ret.push(`  if (data${dataKey} && entity${entityKey} && !entity${entityKey}.${this.safeKey(prop2.name)}) {`);
+                    ret.push(`    entity${entityKey}.${prop.ref ? 'unwrap().' : ''}${this.safeKey(prop2.name)} = ${prop2.ref ? 'Reference.create(entity)' : 'entity'};`);
+                    ret.push(`  }`);
+                }
+            }
+            if (prop.customType?.ensureComparable(meta, prop)) {
+                context.set(`convertToDatabaseValue_${this.safeKey(prop.name)}`, (val) => prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'hydration' }));
+                ret.push(`  if (data${dataKey} != null && convertCustomTypes) {`);
+                ret.push(`    data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getPrimaryKey());`);
+                ret.push(`  }`);
+            }
+            return ret;
+        };
+        const hydrateToMany = (prop, dataKey, entityKey) => {
+            const ret = [];
+            ret.push(...this.createCollectionItemMapper(prop));
+            ret.push(`  if (data${dataKey} && !Array.isArray(data${dataKey}) && typeof data${dataKey} === 'object') {`);
+            ret.push(`    data${dataKey} = [data${dataKey}];`);
+            ret.push(`  }`);
+            ret.push(`  if (Array.isArray(data${dataKey})) {`);
+            ret.push(`    const items = data${dataKey}.map(value => createCollectionItem_${this.safeKey(prop.name)}(value, entity));`);
+            ret.push(`    const coll = Collection.create(entity, '${prop.name}', items, newEntity);`);
+            ret.push(`    if (newEntity) {`);
+            ret.push(`      coll.setDirty();`);
+            ret.push(`    } else {`);
+            ret.push(`      coll.takeSnapshot(true);`);
+            ret.push(`    }`);
+            ret.push(`  } else if (!entity${entityKey} && data${dataKey} instanceof Collection) {`);
+            ret.push(`    entity${entityKey} = data${dataKey};`);
+            ret.push(`  } else if (!entity${entityKey}) {`);
+            const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
+            ret.push(`    const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`);
+            ret.push(`    coll.setDirty(false);`);
+            ret.push(`  }`);
+            return ret;
+        };
+        const registerEmbeddedPrototype = (prop, path) => {
+            const convertorKey = path.filter(k => !k.match(/\[idx_\d+]/)).map(k => this.safeKey(k)).join('_');
+            if (prop.targetMeta?.polymorphs) {
+                prop.targetMeta.polymorphs.forEach(meta => {
+                    context.set(`prototype_${convertorKey}_${meta.className}`, meta.prototype);
+                });
+            }
+            else {
+                context.set(`prototype_${convertorKey}`, prop.embeddable.prototype);
+            }
+        };
+        const parseObjectEmbeddable = (prop, dataKey, ret) => {
+            if (!this.platform.convertsJsonAutomatically() && (prop.object || prop.array)) {
+                context.set('parseJsonSafe', Utils_1.parseJsonSafe);
+                ret.push(`  if (typeof data${dataKey} === 'string') {`, `    data${dataKey} = parseJsonSafe(data${dataKey});`, `  }`);
+            }
+        };
+        const createCond = (prop, dataKey, cond) => {
+            const conds = [];
+            if (prop.object) {
+                conds.push(`data${dataKey} ${cond ?? '!= null'}`);
+            }
+            else {
+                const notNull = cond ?? (prop.nullable ? '!= null' : '!== undefined');
+                meta.props
+                    .filter(p => p.embedded?.[0] === prop.name)
+                    .forEach(p => {
+                    if (p.kind === enums_1.ReferenceKind.EMBEDDED && !p.object && !p.array) {
+                        conds.push(...createCond(p, dataKey + this.wrap(p.embedded[1]), cond));
+                        return;
+                    }
+                    conds.push(`data${this.wrap(p.name)} ${notNull}`);
+                });
+            }
+            return conds;
+        };
+        const hydrateEmbedded = (prop, path, dataKey) => {
+            const entityKey = path.map(k => this.wrap(k)).join('');
+            const ret = [];
+            registerEmbeddedPrototype(prop, path);
+            parseObjectEmbeddable(prop, dataKey, ret);
+            ret.push(`  if (${createCond(prop, dataKey).join(' || ')}) {`);
+            if (prop.targetMeta?.polymorphs) {
+                prop.targetMeta.polymorphs.forEach(meta => {
+                    const childProp = prop.embeddedProps[prop.targetMeta.discriminatorColumn];
+                    const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                    // weak comparison as we can have numbers that might have been converted to strings due to being object keys
+                    ret.push(`    if (data${childDataKey} == '${meta.discriminatorValue}' && entity${entityKey} == null) {`);
+                    ret.push(`      entity${entityKey} = factory.createEmbeddable('${meta.className}', data${prop.object ? dataKey : ''}, { newEntity, convertCustomTypes });`);
+                    ret.push(`    }`);
+                });
+            }
+            else {
+                ret.push(`    if (entity${entityKey} == null) {`);
+                ret.push(`      entity${entityKey} = factory.createEmbeddable('${prop.targetMeta.className}', data${prop.object ? dataKey : ''}, { newEntity, convertCustomTypes });`);
+                ret.push(`    }`);
+            }
+            meta.props
+                .filter(p => p.embedded?.[0] === prop.name)
+                .forEach(childProp => {
+                const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                ret.push(...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(l => '  ' + l));
+            });
+            /* istanbul ignore next */
+            const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
+            if (prop.object) {
+                ret.push(`  } else if (data${dataKey} === null) {`);
+            }
+            else {
+                ret.push(`  } else if (${createCond(prop, dataKey, '=== null').join(' && ')}) {`);
+            }
+            ret.push(`    entity${entityKey} = ${nullVal};`);
+            ret.push(`  }`);
+            return ret;
+        };
+        const hydrateEmbeddedArray = (prop, path, dataKey) => {
+            const entityKey = path.map(k => this.wrap(k)).join('');
+            const ret = [];
+            const idx = this.tmpIndex++;
+            registerEmbeddedPrototype(prop, path);
+            parseObjectEmbeddable(prop, dataKey, ret);
+            ret.push(`  if (Array.isArray(data${dataKey})) {`);
+            ret.push(`    entity${entityKey} = [];`);
+            ret.push(`    data${dataKey}.forEach((_, idx_${idx}) => {`);
+            ret.push(...hydrateEmbedded(prop, [...path, `[idx_${idx}]`], `${dataKey}[idx_${idx}]`).map(l => '    ' + l));
+            ret.push(`    });`);
+            ret.push(`  }`);
+            return ret;
+        };
+        const hydrateProperty = (prop, object = prop.object, path = [prop.name], dataKey) => {
+            const entityKey = path.map(k => this.wrap(k)).join('');
+            dataKey = dataKey ?? (object ? entityKey : this.wrap(prop.name));
+            const ret = [];
+            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.mapToPk) {
+                ret.push(...hydrateToOne(prop, dataKey, entityKey));
+            }
+            else if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY || prop.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+                ret.push(...hydrateToMany(prop, dataKey, entityKey));
+            }
+            else if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+                if (prop.array) {
+                    ret.push(...hydrateEmbeddedArray(prop, path, dataKey));
+                }
+                else {
+                    ret.push(...hydrateEmbedded(prop, path, dataKey));
+                    if (!prop.object) {
+                        ret.push(...hydrateEmbedded({ ...prop, object: true }, path, dataKey));
+                    }
+                }
+            }
+            else { // ReferenceKind.SCALAR
+                ret.push(...hydrateScalar(prop, object, path, dataKey));
+            }
+            if (this.config.get('forceUndefined')) {
+                ret.push(`  if (data${dataKey} === null) entity${entityKey} = undefined;`);
+            }
+            return ret;
+        };
+        for (const prop of props) {
+            lines.push(...hydrateProperty(prop));
+        }
+        const code = `// compiled hydrator for entity ${meta.className} (${type})\n`
+            + `return function(entity, data, factory, newEntity, convertCustomTypes, schema) {\n`
+            + `${lines.join('\n')}\n}`;
+        const hydrator = Utils_1.Utils.createFunction(context, code);
+        this.hydrators[type].set(meta.className, hydrator);
+        return hydrator;
+    }
+    createCollectionItemMapper(prop) {
+        const meta = this.metadata.get(prop.type);
+        const lines = [];
+        lines.push(`  const createCollectionItem_${this.safeKey(prop.name)} = (value, entity) => {`);
+        const prop2 = prop.targetMeta?.properties[prop.mappedBy];
+        if (prop2?.primary) {
+            lines.push(`    if (typeof value === 'object' && value?.['${prop2.name}'] == null) {`);
+            lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
+            lines.push(`    }`);
+        }
+        lines.push(`    if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference('${prop.type}', value, { convertCustomTypes, schema, merge: true });`);
+        lines.push(`    if (value && value.__entity) return value;`);
+        if (prop2 && !prop2.primary) {
+            lines.push(`    if (typeof value === 'object' && value?.['${prop2.name}'] == null) {`);
+            lines.push(`      value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`);
+            lines.push(`    }`);
+        }
+        lines.push(`    return factory.create('${prop.type}', value, { newEntity, convertCustomTypes, schema, merge: true });`);
+        lines.push(`  }`);
+        return lines;
+    }
+    wrap(key) {
+        if (key.match(/^\[.*]$/)) {
+            return key;
+        }
+        return key.match(/^\w+$/) ? `.${key}` : `['${key}']`;
+    }
+    safeKey(key) {
+        return key.replace(/\W/g, '_');
+    }
+}
+exports.ObjectHydrator = ObjectHydrator;

package/hydration/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Hydrator';
+export * from './ObjectHydrator';

package/hydration/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Hydrator"), exports);
+__exportStar(require("./ObjectHydrator"), exports);

package/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @packageDocumentation
+ * @module core
+ */
+export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, } from './typings';
+export * from './enums';
+export * from './errors';
+export * from './exceptions';
+export * from './MikroORM';
+export * from './entity';
+export * from './serialization';
+export * from './events';
+export * from './EntityManager';
+export * from './unit-of-work';
+export * from './utils';
+export * from './logging';
+export * from './hydration';
+export * from './drivers';
+export * from './connections';
+export * from './platforms';
+export * from './types';
+export * from './naming-strategy';
+export * from './metadata';
+export * from './cache';
+export * from './decorators';

package/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.HiddenProps = exports.EagerProps = exports.OptionalProps = exports.EntityRepositoryType = exports.EntityMetadata = exports.PrimaryKeyProp = void 0;
+/**
+ * @packageDocumentation
+ * @module core
+ */
+/* istanbul ignore file */
+var typings_1 = require("./typings");
+Object.defineProperty(exports, "PrimaryKeyProp", { enumerable: true, get: function () { return typings_1.PrimaryKeyProp; } });
+Object.defineProperty(exports, "EntityMetadata", { enumerable: true, get: function () { return typings_1.EntityMetadata; } });
+Object.defineProperty(exports, "EntityRepositoryType", { enumerable: true, get: function () { return typings_1.EntityRepositoryType; } });
+Object.defineProperty(exports, "OptionalProps", { enumerable: true, get: function () { return typings_1.OptionalProps; } });
+Object.defineProperty(exports, "EagerProps", { enumerable: true, get: function () { return typings_1.EagerProps; } });
+Object.defineProperty(exports, "HiddenProps", { enumerable: true, get: function () { return typings_1.HiddenProps; } });
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return typings_1.Config; } });
+__exportStar(require("./enums"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./exceptions"), exports);
+__exportStar(require("./MikroORM"), exports);
+__exportStar(require("./entity"), exports);
+__exportStar(require("./serialization"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./EntityManager"), exports);
+__exportStar(require("./unit-of-work"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./logging"), exports);
+__exportStar(require("./hydration"), exports);
+__exportStar(require("./drivers"), exports);
+__exportStar(require("./connections"), exports);
+__exportStar(require("./platforms"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./naming-strategy"), exports);
+__exportStar(require("./metadata"), exports);
+__exportStar(require("./cache"), exports);
+__exportStar(require("./decorators"), exports);

package/index.mjs

@@ -0,0 +1,192 @@
+import mod from "./index.js";
+
+export default mod;
+export const ALIAS_REPLACEMENT = mod.ALIAS_REPLACEMENT;
+export const ALIAS_REPLACEMENT_RE = mod.ALIAS_REPLACEMENT_RE;
+export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
+export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
+export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
+export const AfterCreate = mod.AfterCreate;
+export const AfterDelete = mod.AfterDelete;
+export const AfterUpdate = mod.AfterUpdate;
+export const AfterUpsert = mod.AfterUpsert;
+export const ArrayCollection = mod.ArrayCollection;
+export const ArrayType = mod.ArrayType;
+export const BaseEntity = mod.BaseEntity;
+export const BeforeCreate = mod.BeforeCreate;
+export const BeforeDelete = mod.BeforeDelete;
+export const BeforeUpdate = mod.BeforeUpdate;
+export const BeforeUpsert = mod.BeforeUpsert;
+export const BigIntType = mod.BigIntType;
+export const BlobType = mod.BlobType;
+export const BooleanType = mod.BooleanType;
+export const Cascade = mod.Cascade;
+export const ChangeSet = mod.ChangeSet;
+export const ChangeSetComputer = mod.ChangeSetComputer;
+export const ChangeSetPersister = mod.ChangeSetPersister;
+export const ChangeSetType = mod.ChangeSetType;
+export const Check = mod.Check;
+export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
+export const Collection = mod.Collection;
+export const CommitOrderCalculator = mod.CommitOrderCalculator;
+export const Config = mod.Config;
+export const Configuration = mod.Configuration;
+export const ConfigurationLoader = mod.ConfigurationLoader;
+export const Connection = mod.Connection;
+export const ConnectionException = mod.ConnectionException;
+export const ConstraintViolationException = mod.ConstraintViolationException;
+export const CreateRequestContext = mod.CreateRequestContext;
+export const Cursor = mod.Cursor;
+export const CursorError = mod.CursorError;
+export const DatabaseDriver = mod.DatabaseDriver;
+export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
+export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
+export const DataloaderType = mod.DataloaderType;
+export const DataloaderUtils = mod.DataloaderUtils;
+export const DateTimeType = mod.DateTimeType;
+export const DateType = mod.DateType;
+export const DeadlockException = mod.DeadlockException;
+export const DecimalType = mod.DecimalType;
+export const DefaultLogger = mod.DefaultLogger;
+export const DoubleType = mod.DoubleType;
+export const DriverException = mod.DriverException;
+export const EagerProps = mod.EagerProps;
+export const Embeddable = mod.Embeddable;
+export const Embedded = mod.Embedded;
+export const EnsureRequestContext = mod.EnsureRequestContext;
+export const Entity = mod.Entity;
+export const EntityAssigner = mod.EntityAssigner;
+export const EntityCaseNamingStrategy = mod.EntityCaseNamingStrategy;
+export const EntityComparator = mod.EntityComparator;
+export const EntityFactory = mod.EntityFactory;
+export const EntityHelper = mod.EntityHelper;
+export const EntityIdentifier = mod.EntityIdentifier;
+export const EntityLoader = mod.EntityLoader;
+export const EntityManager = mod.EntityManager;
+export const EntityManagerType = mod.EntityManagerType;
+export const EntityMetadata = mod.EntityMetadata;
+export const EntityRepository = mod.EntityRepository;
+export const EntityRepositoryType = mod.EntityRepositoryType;
+export const EntitySchema = mod.EntitySchema;
+export const EntitySerializer = mod.EntitySerializer;
+export const EntityTransformer = mod.EntityTransformer;
+export const EntityValidator = mod.EntityValidator;
+export const Enum = mod.Enum;
+export const EnumArrayType = mod.EnumArrayType;
+export const EnumType = mod.EnumType;
+export const EventManager = mod.EventManager;
+export const EventType = mod.EventType;
+export const EventTypeMap = mod.EventTypeMap;
+export const ExceptionConverter = mod.ExceptionConverter;
+export const FileCacheAdapter = mod.FileCacheAdapter;
+export const Filter = mod.Filter;
+export const FloatType = mod.FloatType;
+export const FlushMode = mod.FlushMode;
+export const ForeignKeyConstraintViolationException = mod.ForeignKeyConstraintViolationException;
+export const Formula = mod.Formula;
+export const GeneratedCacheAdapter = mod.GeneratedCacheAdapter;
+export const GroupOperator = mod.GroupOperator;
+export const HiddenProps = mod.HiddenProps;
+export const Hydrator = mod.Hydrator;
+export const IdentityMap = mod.IdentityMap;
+export const Index = mod.Index;
+export const IntegerType = mod.IntegerType;
+export const IntervalType = mod.IntervalType;
+export const InvalidFieldNameException = mod.InvalidFieldNameException;
+export const IsolationLevel = mod.IsolationLevel;
+export const JsonProperty = mod.JsonProperty;
+export const JsonType = mod.JsonType;
+export const LoadStrategy = mod.LoadStrategy;
+export const LockMode = mod.LockMode;
+export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
+export const ManyToMany = mod.ManyToMany;
+export const ManyToOne = mod.ManyToOne;
+export const MediumIntType = mod.MediumIntType;
+export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
+export const MetadataDiscovery = mod.MetadataDiscovery;
+export const MetadataError = mod.MetadataError;
+export const MetadataProvider = mod.MetadataProvider;
+export const MetadataStorage = mod.MetadataStorage;
+export const MetadataValidator = mod.MetadataValidator;
+export const MikroORM = mod.MikroORM;
+export const MongoNamingStrategy = mod.MongoNamingStrategy;
+export const NodeState = mod.NodeState;
+export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
+export const NotFoundError = mod.NotFoundError;
+export const NotNullConstraintViolationException = mod.NotNullConstraintViolationException;
+export const NullCacheAdapter = mod.NullCacheAdapter;
+export const NullHighlighter = mod.NullHighlighter;
+export const ObjectBindingPattern = mod.ObjectBindingPattern;
+export const ObjectHydrator = mod.ObjectHydrator;
+export const OnInit = mod.OnInit;
+export const OnLoad = mod.OnLoad;
+export const OneToMany = mod.OneToMany;
+export const OneToOne = mod.OneToOne;
+export const OptimisticLockError = mod.OptimisticLockError;
+export const OptionalProps = mod.OptionalProps;
+export const PlainObject = mod.PlainObject;
+export const Platform = mod.Platform;
+export const PopulateHint = mod.PopulateHint;
+export const PrimaryKey = mod.PrimaryKey;
+export const PrimaryKeyProp = mod.PrimaryKeyProp;
+export const Property = mod.Property;
+export const QueryFlag = mod.QueryFlag;
+export const QueryHelper = mod.QueryHelper;
+export const QueryOperator = mod.QueryOperator;
+export const QueryOrder = mod.QueryOrder;
+export const QueryOrderNumeric = mod.QueryOrderNumeric;
+export const RawQueryFragment = mod.RawQueryFragment;
+export const ReadOnlyException = mod.ReadOnlyException;
+export const Ref = mod.Ref;
+export const Reference = mod.Reference;
+export const ReferenceKind = mod.ReferenceKind;
+export const ReflectMetadataProvider = mod.ReflectMetadataProvider;
+export const RequestContext = mod.RequestContext;
+export const SCALAR_TYPES = mod.SCALAR_TYPES;
+export const ScalarReference = mod.ScalarReference;
+export const SerializationContext = mod.SerializationContext;
+export const SerializedPrimaryKey = mod.SerializedPrimaryKey;
+export const ServerException = mod.ServerException;
+export const SimpleLogger = mod.SimpleLogger;
+export const SmallIntType = mod.SmallIntType;
+export const StringType = mod.StringType;
+export const SyntaxErrorException = mod.SyntaxErrorException;
+export const TableExistsException = mod.TableExistsException;
+export const TableNotFoundException = mod.TableNotFoundException;
+export const TextType = mod.TextType;
+export const TimeType = mod.TimeType;
+export const TinyIntType = mod.TinyIntType;
+export const TransactionContext = mod.TransactionContext;
+export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Type = mod.Type;
+export const Uint8ArrayType = mod.Uint8ArrayType;
+export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;
+export const Unique = mod.Unique;
+export const UniqueConstraintViolationException = mod.UniqueConstraintViolationException;
+export const UnitOfWork = mod.UnitOfWork;
+export const UnknownType = mod.UnknownType;
+export const Utils = mod.Utils;
+export const UuidType = mod.UuidType;
+export const ValidationError = mod.ValidationError;
+export const WrappedEntity = mod.WrappedEntity;
+export const assign = mod.assign;
+export const colors = mod.colors;
+export const compareArrays = mod.compareArrays;
+export const compareBooleans = mod.compareBooleans;
+export const compareBuffers = mod.compareBuffers;
+export const compareObjects = mod.compareObjects;
+export const createSqlFunction = mod.createSqlFunction;
+export const defineConfig = mod.defineConfig;
+export const equals = mod.equals;
+export const getOnConflictFields = mod.getOnConflictFields;
+export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
+export const helper = mod.helper;
+export const parseJsonSafe = mod.parseJsonSafe;
+export const raw = mod.raw;
+export const ref = mod.ref;
+export const rel = mod.rel;
+export const serialize = mod.serialize;
+export const sql = mod.sql;
+export const t = mod.t;
+export const types = mod.types;
+export const wrap = mod.wrap;

package/logging/DefaultLogger.d.ts

@@ -0,0 +1,32 @@
+import type { Logger, LoggerNamespace, LogContext, LoggerOptions } from './Logger';
+export declare class DefaultLogger implements Logger {
+    private readonly options;
+    debugMode: boolean | LoggerNamespace[];
+    readonly writer: (message: string) => void;
+    private readonly usesReplicas?;
+    private readonly highlighter?;
+    constructor(options: LoggerOptions);
+    /**
+     * @inheritDoc
+     */
+    log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    error(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    warn(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
+    isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
+    /**
+     * @inheritDoc
+     */
+    logQuery(context: {
+        query: string;
+    } & LogContext): void;
+}