@mikro-orm/core 7.0.0-dev.260 → 7.0.0-dev.261

package/EntityManager.js

@@ -1,7 +1,6 @@
 import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
-import { DataloaderUtils } from './utils/DataloaderUtils.js';
 import { QueryHelper } from './utils/QueryHelper.js';
 import { TransactionContext } from './utils/TransactionContext.js';
 import { isRaw, Raw } from './utils/RawQueryFragment.js';
@@ -1816,6 +1815,7 @@ export class EntityManager {
         if (em.loaders[type]) {
             return em.loaders[type];
         }
+        const { DataloaderUtils } = await import('@mikro-orm/core/dataloader');
         const DataLoader = await DataloaderUtils.getDataLoader();
         switch (type) {
             case 'ref': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getRefBatchLoadFn(em)));

package/index.d.ts

@@ -3,7 +3,7 @@
  * @module core
  */
 export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName } from './typings.js';
-export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.260",
+  "version": "7.0.0-dev.261",
   "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",
@@ -13,7 +13,10 @@
     "./fs-utils": {
       "node": "./utils/fs-utils.js",
       "browser": "./not-supported.js"
-    }
+    },
+    "./migrations": "./utils/AbstractMigrator.js",
+    "./schema": "./utils/AbstractSchemaGenerator.js",
+    "./dataloader": "./utils/DataloaderUtils.js"
   },
   "repository": {
     "type": "git",

package/typings.d.ts

@@ -818,7 +818,7 @@ export interface GenerateOptions {
 export interface IEntityGenerator {
     generate(options?: GenerateOptions): Promise<string[]>;
 }
-export type UmzugMigration = {
+export type MigrationInfo = {
     name: string;
     path?: string;
 };
@@ -838,6 +838,14 @@ export type MigrationRow = {
     name: string;
     executed_at: Date;
 };
+/**
+ * @internal
+ */
+export interface IMigrationRunner {
+    run(migration: Migration, method: 'up' | 'down'): Promise<void>;
+    setMasterMigration(trx: Transaction): void;
+    unsetMasterMigration(): void;
+}
 /**
  * @internal
  */
@@ -878,23 +886,23 @@ export interface IMigrator {
     /**
      * Returns list of pending (not yet executed) migrations found in the migration directory.
      */
-    getPending(): Promise<UmzugMigration[]>;
+    getPending(): Promise<MigrationInfo[]>;
     /**
      * Executes specified migrations. Without parameter it will migrate up to the latest version.
      */
-    up(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    up(options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
     /**
      * Executes down migrations to the given point. Without parameter it will migrate one version down.
      */
-    down(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
     /**
      * Registers event handler.
      */
-    on(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    on(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
     /**
      * Removes event handler.
      */
-    off(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    off(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
     /**
      * @internal
      */
@@ -922,6 +930,10 @@ export interface IMigrationGenerator {
 export interface Migration {
     up(): Promise<void> | void;
     down(): Promise<void> | void;
+    isTransactional(): boolean;
+    reset(): void;
+    setTransactionContext(ctx: Transaction): void;
+    getQueries?(): any[];
 }
 export interface MigrationObject {
     name: string;

package/utils/AbstractMigrator.d.ts

@@ -0,0 +1,101 @@
+import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationRow, MigratorEvent } from '../typings.js';
+import type { Transaction } from '../connections/Connection.js';
+import type { Configuration, MigrationsOptions } from './Configuration.js';
+import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+interface RunnableMigration {
+    name: string;
+    path?: string;
+    up: () => MaybePromise<void>;
+    down: () => MaybePromise<void>;
+}
+type MigrateOptions = {
+    from?: string | number;
+    to?: string | number;
+    migrations?: string[];
+    transaction?: Transaction;
+};
+export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implements IMigrator {
+    protected readonly em: D[typeof EntityManagerType];
+    protected runner: IMigrationRunner;
+    protected storage: IMigratorStorage;
+    protected generator: IMigrationGenerator;
+    protected readonly driver: D;
+    protected readonly config: Configuration;
+    protected readonly options: MigrationsOptions;
+    protected absolutePath: string;
+    protected initialized: boolean;
+    private readonly listeners;
+    constructor(em: D[typeof EntityManagerType]);
+    protected abstract createRunner(): IMigrationRunner;
+    protected abstract createStorage(): IMigratorStorage;
+    protected abstract getDefaultGenerator(): IMigrationGenerator;
+    abstract create(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<{
+        fileName: string;
+        code: string;
+        diff: {
+            up: string[];
+            down: string[];
+        };
+    }>;
+    abstract checkSchema(): Promise<boolean>;
+    abstract createInitial(path?: string, name?: string, blank?: boolean): Promise<{
+        fileName: string;
+        code: string;
+        diff: {
+            up: string[];
+            down: string[];
+        };
+    }>;
+    /**
+     * @inheritDoc
+     */
+    on(eventName: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): this;
+    /**
+     * @inheritDoc
+     */
+    off(eventName: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): this;
+    /**
+     * @inheritDoc
+     */
+    getExecuted(): Promise<MigrationRow[]>;
+    /**
+     * @inheritDoc
+     */
+    getPending(): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    up(options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    abstract getStorage(): IMigratorStorage;
+    protected init(): Promise<void>;
+    protected initServices(): void;
+    protected resolve(params: {
+        name: string;
+        path: string;
+    }): RunnableMigration;
+    protected initialize(MigrationClass: Constructor<Migration>, name: string): RunnableMigration;
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    private detectSourceFolder;
+    private registerDefaultListeners;
+    private emit;
+    private discoverMigrations;
+    private executeMigrations;
+    private filterUp;
+    private filterDown;
+    private getMigrationFilename;
+    private prefix;
+    private runMigrations;
+    private runInTransaction;
+}
+export {};

package/utils/AbstractMigrator.js

@@ -0,0 +1,305 @@
+import { Utils } from './Utils.js';
+export class AbstractMigrator {
+    em;
+    runner;
+    storage;
+    generator;
+    driver;
+    config;
+    options;
+    absolutePath;
+    initialized = false;
+    listeners = new Map();
+    constructor(em) {
+        this.em = em;
+        this.driver = this.em.getDriver();
+        this.config = this.em.config;
+        this.options = this.config.get('migrations');
+        this.initServices();
+        this.registerDefaultListeners();
+    }
+    /**
+     * @inheritDoc
+     */
+    on(eventName, listener) {
+        if (!this.listeners.has(eventName)) {
+            this.listeners.set(eventName, new Set());
+        }
+        this.listeners.get(eventName).add(listener);
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    off(eventName, listener) {
+        this.listeners.get(eventName)?.delete(listener);
+        return this;
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecuted() {
+        await this.init();
+        return this.storage.getExecutedMigrations();
+    }
+    /**
+     * @inheritDoc
+     */
+    async getPending() {
+        await this.init();
+        const all = await this.discoverMigrations();
+        const executed = new Set(await this.storage.executed());
+        return all
+            .filter(m => !executed.has(m.name))
+            .map(m => ({ name: m.name, path: m.path }));
+    }
+    /**
+     * @inheritDoc
+     */
+    async up(options) {
+        return this.runMigrations('up', options);
+    }
+    /**
+     * @inheritDoc
+     */
+    async down(options) {
+        return this.runMigrations('down', options);
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        if (!this.options.migrationsList) {
+            const { fs } = await import('@mikro-orm/core/fs-utils');
+            this.detectSourceFolder(fs);
+            /* v8 ignore next */
+            const key = (this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs) ? 'pathTs' : 'path';
+            this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
+            fs.ensureDir(this.absolutePath);
+        }
+    }
+    initServices() {
+        this.runner = this.createRunner();
+        this.storage = this.createStorage();
+        if (this.options.generator) {
+            this.generator = new this.options.generator(this.driver, this.config.getNamingStrategy(), this.options);
+        }
+        else {
+            this.generator = this.getDefaultGenerator();
+        }
+    }
+    resolve(params) {
+        const createMigrationHandler = async (method) => {
+            const { fs } = await import('@mikro-orm/core/fs-utils');
+            const migration = await fs.dynamicImport(params.path);
+            const MigrationClass = Object.values(migration).find(cls => typeof cls === 'function' && typeof cls.constructor === 'function');
+            const instance = new MigrationClass(this.driver, this.config);
+            await this.runner.run(instance, method);
+        };
+        return {
+            name: this.storage.getMigrationName(params.name),
+            path: params.path,
+            up: () => createMigrationHandler('up'),
+            down: () => createMigrationHandler('down'),
+        };
+    }
+    initialize(MigrationClass, name) {
+        const instance = new MigrationClass(this.driver, this.config);
+        return {
+            name: this.storage.getMigrationName(name),
+            up: () => this.runner.run(instance, 'up'),
+            down: () => this.runner.run(instance, 'down'),
+        };
+    }
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    detectSourceFolder(fs) {
+        const baseDir = this.config.get('baseDir');
+        const defaultPath = './migrations';
+        if (!fs.pathExists(baseDir + '/src')) {
+            this.options.path ??= defaultPath;
+            return;
+        }
+        const exists = fs.pathExists(`${baseDir}/${defaultPath}`);
+        const distDir = fs.pathExists(baseDir + '/dist');
+        const buildDir = fs.pathExists(baseDir + '/build');
+        // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
+        /* v8 ignore next */
+        const path = distDir ? './dist' : (buildDir ? './build' : './src');
+        // only if the user did not provide any values and if the default path does not exist
+        if (!this.options.path && !this.options.pathTs && !exists) {
+            this.options.path = `${path}/migrations`;
+            this.options.pathTs = './src/migrations';
+        }
+    }
+    registerDefaultListeners() {
+        /* v8 ignore else */
+        if (!this.options.silent) {
+            const logger = this.config.getLogger();
+            this.on('migrating', event => logger.log('migrator', `Processing '${event.name}'`, { enabled: true }));
+            this.on('migrated', event => logger.log('migrator', `Applied '${event.name}'`, { enabled: true }));
+            this.on('reverting', event => logger.log('migrator', `Processing '${event.name}'`, { enabled: true }));
+            this.on('reverted', event => logger.log('migrator', `Reverted '${event.name}'`, { enabled: true }));
+        }
+    }
+    async emit(event, data) {
+        for (const listener of this.listeners.get(event) ?? []) {
+            await listener(data);
+        }
+    }
+    async discoverMigrations() {
+        if (this.options.migrationsList) {
+            return this.options.migrationsList.map(migration => {
+                if (typeof migration === 'function') {
+                    return this.initialize(migration, migration.name);
+                }
+                return this.initialize(migration.class, migration.name);
+            });
+        }
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const pattern = fs.normalizePath(this.absolutePath, this.options.glob);
+        const files = fs.glob(pattern).sort();
+        return files.map(filePath => this.resolve({
+            name: filePath.replace(/\\/g, '/').split('/').pop(),
+            path: filePath,
+        }));
+    }
+    async executeMigrations(method, options = {}) {
+        const all = await this.discoverMigrations();
+        const executed = await this.storage.executed();
+        const executedSet = new Set(executed);
+        let toRun;
+        if (method === 'up') {
+            toRun = this.filterUp(all, executedSet, options);
+        }
+        else {
+            toRun = this.filterDown(all, executed, options);
+        }
+        const result = [];
+        const eventBefore = method === 'up' ? 'migrating' : 'reverting';
+        const eventAfter = method === 'up' ? 'migrated' : 'reverted';
+        for (const migration of toRun) {
+            const event = { name: migration.name, path: migration.path };
+            await this.emit(eventBefore, event);
+            await migration[method]();
+            if (method === 'up') {
+                await this.storage.logMigration({ name: migration.name });
+            }
+            else {
+                await this.storage.unlogMigration({ name: migration.name });
+            }
+            await this.emit(eventAfter, event);
+            result.push(event);
+        }
+        return result;
+    }
+    filterUp(all, executed, options) {
+        let pending = all.filter(m => !executed.has(m.name));
+        if (options.migrations) {
+            const set = new Set(options.migrations);
+            return pending.filter(m => set.has(m.name));
+        }
+        if (options.from) {
+            const idx = all.findIndex(m => m.name === options.from);
+            if (idx >= 0) {
+                const names = new Set(all.slice(idx + 1).map(m => m.name));
+                pending = pending.filter(m => names.has(m.name));
+            }
+        }
+        if (options.to && typeof options.to === 'string') {
+            const idx = all.findIndex(m => m.name === options.to);
+            if (idx >= 0) {
+                const names = new Set(all.slice(0, idx + 1).map(m => m.name));
+                pending = pending.filter(m => names.has(m.name));
+            }
+        }
+        return pending;
+    }
+    filterDown(all, executed, options) {
+        const migrationMap = new Map(all.map(m => [m.name, m]));
+        const executedReversed = [...executed].reverse();
+        if (options.migrations) {
+            const set = new Set(options.migrations);
+            return executedReversed
+                .filter(name => set.has(name))
+                .map(name => migrationMap.get(name))
+                .filter(Boolean);
+        }
+        if (options.to === 0) {
+            return executedReversed.map(name => migrationMap.get(name)).filter(Boolean);
+        }
+        if (options.to) {
+            const result = [];
+            for (const name of executedReversed) {
+                if (name === String(options.to)) {
+                    break;
+                }
+                const m = migrationMap.get(name);
+                if (m) {
+                    result.push(m);
+                }
+            }
+            return result;
+        }
+        // Default: revert last 1
+        if (executedReversed.length > 0) {
+            const m = migrationMap.get(executedReversed[0]);
+            return m ? [m] : [];
+        }
+        return [];
+    }
+    getMigrationFilename(name) {
+        name = name.replace(/\.[jt]s$/, '');
+        return name.match(/^\d{14}$/) ? this.options.fileName(name) : name;
+    }
+    prefix(options) {
+        if (typeof options === 'string' || Array.isArray(options)) {
+            return { migrations: Utils.asArray(options).map(name => this.getMigrationFilename(name)) };
+        }
+        if (!options) {
+            return {};
+        }
+        const result = {};
+        if (options.migrations) {
+            result.migrations = options.migrations.map(name => this.getMigrationFilename(name));
+        }
+        if (options.from) {
+            result.from = this.getMigrationFilename(String(options.from));
+        }
+        if (options.to && options.to !== 0) {
+            result.to = this.getMigrationFilename(String(options.to));
+        }
+        else if (options.to === 0) {
+            result.to = 0;
+        }
+        return result;
+    }
+    async runMigrations(method, options) {
+        await this.init();
+        if (!this.options.transactional || !this.options.allOrNothing) {
+            return this.executeMigrations(method, this.prefix(options));
+        }
+        if (Utils.isObject(options) && options.transaction) {
+            return this.runInTransaction(options.transaction, method, options);
+        }
+        return this.driver.getConnection().transactional(trx => this.runInTransaction(trx, method, options));
+    }
+    async runInTransaction(trx, method, options) {
+        this.runner.setMasterMigration(trx);
+        this.storage.setMasterMigration(trx);
+        try {
+            return await this.executeMigrations(method, this.prefix(options));
+        }
+        finally {
+            this.runner.unsetMasterMigration();
+            this.storage.unsetMasterMigration();
+        }
+    }
+}

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.260';
+    static #ORM_VERSION = '7.0.0-dev.261';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/fs-utils.d.ts

@@ -28,6 +28,7 @@ export declare const fs: {
      * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
      */
     absolutePath(path: string, baseDir?: string): string;
+    writeFile(path: string, data: string, options?: Record<string, any>): Promise<void>;
     dynamicImport<T = any>(id: string): Promise<T>;
 };
 export * from '../cache/FileCacheAdapter.js';

package/utils/fs-utils.js

@@ -1,4 +1,5 @@
 import { existsSync, globSync as nodeGlobSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { writeFile as nodeWriteFile } from 'node:fs/promises';
 import { isAbsolute, join, normalize, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
@@ -182,6 +183,9 @@ export const fs = {
         }
         return this.normalizePath(path);
     },
+    async writeFile(path, data, options) {
+        await nodeWriteFile(path, data, options);
+    },
     async dynamicImport(id) {
         /* v8 ignore next */
         const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;

package/utils/index.d.ts

@@ -1,6 +1,5 @@
 export * from './Configuration.js';
 export * from './Cursor.js';
-export * from './DataloaderUtils.js';
 export * from './Utils.js';
 export * from './RequestContext.js';
 export * from './TransactionContext.js';
@@ -8,7 +7,6 @@ export * from './TransactionManager.js';
 export * from './QueryHelper.js';
 export * from './NullHighlighter.js';
 export * from './EntityComparator.js';
-export * from './AbstractSchemaGenerator.js';
 export * from './RawQueryFragment.js';
 export * from './env-vars.js';
 export * from './upsert-utils.js';

package/utils/index.js

@@ -1,6 +1,5 @@
 export * from './Configuration.js';
 export * from './Cursor.js';
-export * from './DataloaderUtils.js';
 export * from './Utils.js';
 export * from './RequestContext.js';
 export * from './TransactionContext.js';
@@ -8,7 +7,6 @@ export * from './TransactionManager.js';
 export * from './QueryHelper.js';
 export * from './NullHighlighter.js';
 export * from './EntityComparator.js';
-export * from './AbstractSchemaGenerator.js';
 export * from './RawQueryFragment.js';
 export * from './env-vars.js';
 export * from './upsert-utils.js';