@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/MikroORM.d.ts

@@ -1,14 +1,44 @@
-import type { EntityManagerType, IDatabaseDriver } from './drivers';
-import { type EntitySchema, MetadataStorage } from './metadata';
-import { Configuration, type Options } from './utils';
-import type { EntityManager } from './EntityManager';
-import type { Constructor, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings';
+import type { EntityManagerType, IDatabaseDriver } from './drivers/IDatabaseDriver.js';
+import { type EntitySchema } from './metadata/EntitySchema.js';
+import { MetadataStorage } from './metadata/MetadataStorage.js';
+import { Configuration, type Options } from './utils/Configuration.js';
+import type { EntityManager } from './EntityManager.js';
+import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
+/** @internal */
+export declare function lookupExtensions(options: Options): Promise<void>;
 /**
- * Helper class for bootstrapping the MikroORM.
+ * The main class used to configure and bootstrap the ORM.
+ *
+ * @example
+ * ```ts
+ * // import from driver package
+ * import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
+ *
+ * const User = defineEntity({
+ *   name: 'User',
+ *   properties: {
+ *     id: p.integer().primary(),
+ *     name: p.string(),
+ *   },
+ * });
+ *
+ * const orm = new MikroORM({
+ *   entities: [User],
+ *   dbName: 'my.db',
+ * });
+ * await orm.schema.update();
+ *
+ * const em = orm.em.fork();
+ * const u1 = em.create(User, { name: 'John' });
+ * const u2 = em.create(User, { name: 'Ben' });
+ * await em.flush();
+ * ```
  */
-export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = Driver[typeof EntityManagerType] & EntityManager> {
+export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
-    em: EM;
+    em: EM & {
+        '~entities'?: Entities;
+    };
     readonly driver: Driver;
     readonly config: Configuration<Driver>;
     private metadata;
@@ -18,16 +48,14 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
      * - no loading of the `config` file, `options` parameter is mandatory
      * - no support for folder based discovery
-     * - no check for mismatched package versions
      */
-    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
-    constructor(options: Options<Driver, EM> | Configuration<Driver, EM>);
+    constructor(options: Options<Driver, EM, Entities>);
     /**
      * Connects to the database.
      */
@@ -35,13 +63,13 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Reconnects, possibly to a different database.
      */
-    reconnect(options?: Options): Promise<void>;
+    reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
     /**
      * Checks whether the database connection is active.
      */
     isConnected(): Promise<boolean>;
     /**
-     * Checks whether the database connection is active, returns .
+     * Checks whether the database connection is active, returns the reason if not.
      */
     checkConnection(): Promise<{
         ok: true;
@@ -62,8 +90,6 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
      */
     getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
-    discoverEntities(): Promise<void>;
-    discoverEntitiesSync(): void;
     private createEntityManager;
     /**
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
@@ -72,33 +98,17 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
     /**
      * Gets the SchemaGenerator.
      */
-    getSchemaGenerator(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
-    /**
-     * Gets the EntityGenerator.
-     */
-    getEntityGenerator<T extends IEntityGenerator = IEntityGenerator>(): T;
-    /**
-     * Gets the Migrator.
-     */
-    getMigrator<T extends IMigrator = IMigrator>(): T;
+    get schema(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
     /**
      * Gets the SeedManager
      */
-    getSeeder<T extends ISeedManager = ISeedManager>(): T;
-    /**
-     * Shortcut for `orm.getSchemaGenerator()`
-     */
-    get schema(): ReturnType<ReturnType<Driver["getPlatform"]>["getSchemaGenerator"]>;
-    /**
-     * Shortcut for `orm.getSeeder()`
-     */
     get seeder(): ISeedManager;
     /**
-     * Shortcut for `orm.getMigrator()`
+     * Gets the Migrator.
      */
     get migrator(): IMigrator;
     /**
-     * Shortcut for `orm.getEntityGenerator()`
+     * Gets the EntityGenerator.
      */
     get entityGenerator(): IEntityGenerator;
 }

package/MikroORM.js

@@ -1,14 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MikroORM = void 0;
-const metadata_1 = require("./metadata");
-const utils_1 = require("./utils");
-const logging_1 = require("./logging");
-const cache_1 = require("./cache");
+import { MetadataDiscovery } from './metadata/MetadataDiscovery.js';
+import { MetadataStorage } from './metadata/MetadataStorage.js';
+import { Configuration } from './utils/Configuration.js';
+import { loadEnvironmentVars } from './utils/env-vars.js';
+import { Utils } from './utils/Utils.js';
+import { colors } from './logging/colors.js';
+async function registerExtension(name, mod, extensions) {
+    /* v8 ignore next */
+    const resolved = await mod.catch(() => null);
+    const module = resolved?.[name];
+    /* v8 ignore else */
+    if (module) {
+        extensions.push(module);
+    }
+}
+/** @internal */
+export async function lookupExtensions(options) {
+    const extensions = options.extensions ?? [];
+    const exists = (name) => extensions.some(ext => ext.name === name);
+    if (!exists('SeedManager')) {
+        await registerExtension('SeedManager', import((() => '@mikro-orm/seeder')()), extensions);
+    }
+    if (!exists('Migrator')) {
+        await registerExtension('Migrator', import((() => '@mikro-orm/migrations')()), extensions);
+    }
+    /* v8 ignore if */
+    if (!exists('Migrator')) {
+        await registerExtension('Migrator', import((() => '@mikro-orm/migrations-mongodb')()), extensions);
+    }
+    if (!exists('EntityGenerator')) {
+        await registerExtension('EntityGenerator', import((() => '@mikro-orm/entity-generator')()), extensions);
+    }
+    options.extensions = extensions;
+    const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
+    if (metadataCacheEnabled) {
+        options.metadataCache ??= {};
+        options.metadataCache.adapter ??= await import('@mikro-orm/core/fs-utils').then(m => m.FileCacheAdapter);
+    }
+}
 /**
- * Helper class for bootstrapping the MikroORM.
+ * The main class used to configure and bootstrap the ORM.
+ *
+ * @example
+ * ```ts
+ * // import from driver package
+ * import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
+ *
+ * const User = defineEntity({
+ *   name: 'User',
+ *   properties: {
+ *     id: p.integer().primary(),
+ *     name: p.string(),
+ *   },
+ * });
+ *
+ * const orm = new MikroORM({
+ *   entities: [User],
+ *   dbName: 'my.db',
+ * });
+ * await orm.schema.update();
+ *
+ * const em = orm.em.fork();
+ * const u1 = em.create(User, { name: 'John' });
+ * const u2 = em.create(User, { name: 'Ben' });
+ * await em.flush();
+ * ```
  */
-class MikroORM {
+export class MikroORM {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
     em;
     driver;
@@ -21,43 +78,18 @@ class MikroORM {
      * If you omit the `options` parameter, your CLI config will be used.
      */
     static async init(options) {
-        // for back-compatibility only, used by @mikro-orm/nestjs v5
-        if (options instanceof utils_1.Configuration) {
-            options = options.getAll();
-        }
-        utils_1.ConfigurationLoader.registerDotenv(options);
-        const coreVersion = await utils_1.ConfigurationLoader.checkPackageVersion();
-        const env = utils_1.ConfigurationLoader.loadEnvironmentVars();
+        /* v8 ignore next */
         if (!options) {
-            const configPathFromArg = utils_1.ConfigurationLoader.configPathsFromArg();
-            const config = (await utils_1.ConfigurationLoader.getConfiguration(process.env.MIKRO_ORM_CONTEXT_NAME ?? 'default', configPathFromArg ?? utils_1.ConfigurationLoader.getConfigPaths()));
-            options = config.getAll();
-            if (configPathFromArg) {
-                config.getLogger().warn('deprecated', 'Path for config file was inferred from the command line arguments. Instead, you should set the MIKRO_ORM_CLI_CONFIG environment variable to specify the path, or if you really must use the command line arguments, import the config manually based on them, and pass it to init.', { label: 'D0001' });
-            }
-        }
-        options = utils_1.Utils.mergeConfig(options, env);
-        await utils_1.ConfigurationLoader.commonJSCompat(options);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        orm.logger.log('info', `MikroORM version: ${logging_1.colors.green(coreVersion)}`);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        await orm.discoverEntities();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        if (orm.config.get('connect')) {
-            await orm.connect();
-        }
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        if (orm.config.get('connect') && orm.config.get('ensureIndexes')) {
-            await orm.getSchemaGenerator().ensureIndexes();
-        }
+            throw new Error(`options parameter is required`);
+        }
+        options = { ...options };
+        options.discovery ??= {};
+        options.discovery.skipSyncDiscovery ??= true;
+        await lookupExtensions(options);
+        const orm = new this(options);
+        const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
+        orm.metadata = await orm.discovery.discover(preferTs);
+        orm.createEntityManager();
         return orm;
     }
     /**
@@ -65,74 +97,38 @@ class MikroORM {
      * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
      * - no loading of the `config` file, `options` parameter is mandatory
      * - no support for folder based discovery
-     * - no check for mismatched package versions
      */
-    static initSync(options) {
-        // for back-compatibility only, used by @mikro-orm/nestjs v5
-        if (options instanceof utils_1.Configuration) {
-            options = options.getAll();
-        }
-        utils_1.ConfigurationLoader.registerDotenv(options);
-        const env = utils_1.ConfigurationLoader.loadEnvironmentVars();
-        options = utils_1.Utils.merge(options, env);
-        if ('DRIVER' in this && !options.driver) {
-            options.driver = this.DRIVER;
-        }
-        const orm = new MikroORM(options);
-        // we need to allow global context here as we are not in a scope of requests yet
-        const allowGlobalContext = orm.config.get('allowGlobalContext');
-        orm.config.set('allowGlobalContext', true);
-        orm.discoverEntitiesSync();
-        orm.config.set('allowGlobalContext', allowGlobalContext);
-        orm.driver.getPlatform().init(orm);
-        for (const extension of orm.config.get('extensions')) {
-            extension.register(orm);
-        }
-        return orm;
-    }
     constructor(options) {
-        if (options instanceof utils_1.Configuration) {
-            this.config = options;
-        }
-        else {
-            this.config = new utils_1.Configuration(options);
-        }
+        const env = loadEnvironmentVars();
+        options = Utils.merge(options, env);
+        this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
-        if (discovery.disableDynamicFileAccess) {
-            this.config.set('metadataProvider', metadata_1.ReflectMetadataProvider);
-            this.config.set('metadataCache', { adapter: cache_1.NullCacheAdapter });
-            discovery.requireEntitiesArray = true;
-        }
         this.driver = this.config.getDriver();
         this.logger = this.config.getLogger();
-        this.discovery = new metadata_1.MetadataDiscovery(new metadata_1.MetadataStorage(), this.driver.getPlatform(), this.config);
+        this.logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
+        this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        this.driver.getPlatform().init(this);
+        for (const extension of this.config.get('extensions')) {
+            extension.register(this);
+        }
+        if (!discovery.skipSyncDiscovery) {
+            this.metadata = this.discovery.discoverSync();
+            this.createEntityManager();
+        }
     }
     /**
      * Connects to the database.
      */
     async connect() {
-        const connection = await this.driver.connect();
-        const clientUrl = connection.getClientUrl();
-        const dbName = this.config.get('dbName');
-        const db = dbName + (clientUrl ? ' on ' + clientUrl : '');
-        if (this.config.get('ensureDatabase')) {
-            const options = this.config.get('ensureDatabase');
-            await this.schema.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
-        }
-        if (await this.isConnected()) {
-            this.logger.log('info', `MikroORM successfully connected to database ${logging_1.colors.green(db)}`);
-        }
-        else {
-            this.logger.error('info', `MikroORM failed to connect to database ${db}`);
-        }
+        await this.driver.connect();
         return this.driver;
     }
     /**
      * Reconnects, possibly to a different database.
      */
     async reconnect(options = {}) {
-        /* istanbul ignore next */
-        for (const key of utils_1.Utils.keys(options)) {
+        /* v8 ignore next */
+        for (const key of Utils.keys(options)) {
             this.config.set(key, options[key]);
         }
         await this.driver.reconnect();
@@ -144,7 +140,7 @@ class MikroORM {
         return this.driver.getConnection().isConnected();
     }
     /**
-     * Checks whether the database connection is active, returns .
+     * Checks whether the database connection is active, returns the reason if not.
      */
     async checkConnection() {
         return this.driver.getConnection().checkConnection();
@@ -153,34 +149,20 @@ class MikroORM {
      * Closes the database connection.
      */
     async close(force = false) {
-        if (await this.isConnected()) {
-            await this.driver.close(force);
-        }
-        if (this.config.getMetadataCacheAdapter()?.close) {
-            await this.config.getMetadataCacheAdapter().close();
-        }
-        if (this.config.getResultCacheAdapter()?.close) {
-            await this.config.getResultCacheAdapter().close();
-        }
+        await this.driver.close(force);
+        await this.config.getMetadataCacheAdapter()?.close?.();
+        await this.config.getResultCacheAdapter()?.close?.();
     }
     /**
      * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
      */
     getMetadata(entityName) {
         if (entityName) {
-            entityName = utils_1.Utils.className(entityName);
+            entityName = Utils.className(entityName);
             return this.metadata.get(entityName);
         }
         return this.metadata;
     }
-    async discoverEntities() {
-        this.metadata = await this.discovery.discover(this.config.get('preferTs'));
-        this.createEntityManager();
-    }
-    discoverEntitiesSync() {
-        this.metadata = this.discovery.discoverSync(this.config.get('preferTs'));
-        this.createEntityManager();
-    }
     createEntityManager() {
         this.driver.setMetadata(this.metadata);
         this.em = this.driver.createEntityManager();
@@ -192,73 +174,40 @@ class MikroORM {
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
     discoverEntity(entities, reset) {
-        entities = utils_1.Utils.asArray(entities);
-        for (const className of utils_1.Utils.asArray(reset)) {
+        for (const className of Utils.asArray(reset)) {
             this.metadata.reset(className);
             this.discovery.reset(className);
         }
-        const tmp = this.discovery.discoverReferences(entities);
-        const options = this.config.get('discovery');
-        new metadata_1.MetadataValidator().validateDiscovered([...Object.values(this.metadata.getAll()), ...tmp], options);
+        const tmp = this.discovery.discoverReferences(Utils.asArray(entities));
         const metadata = this.discovery.processDiscoveredEntities(tmp);
-        metadata.forEach(meta => {
+        for (const meta of metadata) {
             this.metadata.set(meta.className, meta);
             meta.root = this.metadata.get(meta.root.className);
-        });
+        }
         this.metadata.decorate(this.em);
     }
     /**
      * Gets the SchemaGenerator.
      */
-    getSchemaGenerator() {
-        const extension = this.config.getExtension('@mikro-orm/schema-generator');
-        if (extension) {
-            return extension;
-        }
-        /* istanbul ignore next */
-        throw new Error(`SchemaGenerator extension not registered.`);
-    }
-    /**
-     * Gets the EntityGenerator.
-     */
-    getEntityGenerator() {
-        return this.driver.getPlatform().getExtension('EntityGenerator', '@mikro-orm/entity-generator', '@mikro-orm/entity-generator', this.em);
-    }
-    /**
-     * Gets the Migrator.
-     */
-    getMigrator() {
-        return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations', this.em);
-    }
-    /**
-     * Gets the SeedManager
-     */
-    getSeeder() {
-        return this.driver.getPlatform().getExtension('SeedManager', '@mikro-orm/seeder', '@mikro-orm/seeder', this.em);
-    }
-    /**
-     * Shortcut for `orm.getSchemaGenerator()`
-     */
     get schema() {
-        return this.getSchemaGenerator();
+        return this.config.getExtension('@mikro-orm/schema-generator');
     }
     /**
-     * Shortcut for `orm.getSeeder()`
+     * Gets the SeedManager
      */
     get seeder() {
-        return this.getSeeder();
+        return this.driver.getPlatform().getExtension('SeedManager', '@mikro-orm/seeder', '@mikro-orm/seeder', this.em);
     }
     /**
-     * Shortcut for `orm.getMigrator()`
+     * Gets the Migrator.
      */
     get migrator() {
-        return this.getMigrator();
+        return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations', this.em);
     }
     /**
-     * Shortcut for `orm.getEntityGenerator()`
+     * Gets the EntityGenerator.
      */
     get entityGenerator() {
-        return this.getEntityGenerator();
+        return this.driver.getPlatform().getExtension('EntityGenerator', '@mikro-orm/entity-generator', '@mikro-orm/entity-generator', this.em);
     }
 }
-exports.MikroORM = MikroORM;

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/cache/CacheAdapter.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cache/FileCacheAdapter.d.ts

@@ -1,4 +1,4 @@
-import type { SyncCacheAdapter } from './CacheAdapter';
+import type { SyncCacheAdapter } from './CacheAdapter.js';
 export declare class FileCacheAdapter implements SyncCacheAdapter {
     private readonly options;
     private readonly baseDir;
@@ -8,7 +8,7 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean);
+    } | undefined, baseDir: string, pretty?: boolean);
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -1,32 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileCacheAdapter = void 0;
-const globby_1 = __importDefault(require("globby"));
-const fs_extra_1 = require("fs-extra");
-const Utils_1 = require("../utils/Utils");
-class FileCacheAdapter {
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { fs } from '../utils/fs-utils.js';
+import { Utils } from '../utils/Utils.js';
+export class FileCacheAdapter {
     options;
     baseDir;
     pretty;
-    VERSION = Utils_1.Utils.getORMVersion();
+    VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false) {
+    constructor(options = {}, baseDir, pretty = false) {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
+        this.options.cacheDir ??= process.cwd() + '/temp';
     }
     /**
      * @inheritDoc
      */
     get(name) {
         const path = this.path(name);
-        if (!(0, fs_extra_1.pathExistsSync)(path)) {
+        if (!existsSync(path)) {
             return null;
         }
-        const payload = (0, fs_extra_1.readJSONSync)(path);
+        const payload = fs.readJSONSync(path);
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;
@@ -43,23 +38,22 @@ class FileCacheAdapter {
         }
         const path = this.path(name);
         const hash = this.getHash(origin);
-        const opts = this.pretty ? { spaces: 2 } : {};
-        (0, fs_extra_1.writeJSONSync)(path, { data, origin, hash, version: this.VERSION }, opts);
+        writeFileSync(path, JSON.stringify({ data, origin, hash, version: this.VERSION }, null, this.pretty ? 2 : undefined));
     }
     /**
      * @inheritDoc
      */
     remove(name) {
         const path = this.path(name);
-        (0, fs_extra_1.unlinkSync)(path);
+        unlinkSync(path);
     }
     /**
      * @inheritDoc
      */
     clear() {
         const path = this.path('*');
-        const files = globby_1.default.sync(path);
-        files.forEach(file => (0, fs_extra_1.unlinkSync)(file));
+        const files = fs.glob(path);
+        files.forEach(file => unlinkSync(file));
         this.cache = {};
     }
     combine() {
@@ -69,22 +63,21 @@ class FileCacheAdapter {
         let path = typeof this.options.combined === 'string'
             ? this.options.combined
             : './metadata.json';
-        path = Utils_1.Utils.normalizePath(this.options.cacheDir, path);
+        path = Utils.normalizePath(this.options.cacheDir, path);
         this.options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
-        (0, fs_extra_1.writeJSONSync)(path, this.cache, { spaces: this.pretty ? 2 : undefined });
+        writeFileSync(path, JSON.stringify(this.cache, null, this.pretty ? 2 : undefined));
         return path;
     }
     path(name) {
-        (0, fs_extra_1.ensureDirSync)(this.options.cacheDir);
+        fs.ensureDir(this.options.cacheDir);
         return `${this.options.cacheDir}/${name}.json`;
     }
     getHash(origin) {
-        origin = Utils_1.Utils.absolutePath(origin, this.baseDir);
-        if (!(0, fs_extra_1.pathExistsSync)(origin)) {
+        origin = Utils.absolutePath(origin, this.baseDir);
+        if (!existsSync(origin)) {
             return null;
         }
-        const contents = (0, fs_extra_1.readFileSync)(origin);
-        return Utils_1.Utils.hash(contents.toString() + this.VERSION);
+        const contents = readFileSync(origin);
+        return Utils.hash(contents.toString() + this.VERSION);
     }
 }
-exports.FileCacheAdapter = FileCacheAdapter;

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,7 +1,6 @@
-import type { CacheAdapter } from './CacheAdapter';
-import type { Dictionary } from '../typings';
+import type { CacheAdapter } from './CacheAdapter.js';
+import type { Dictionary } from '../typings.js';
 export declare class GeneratedCacheAdapter implements CacheAdapter {
-    private readonly options;
     private readonly data;
     constructor(options: {
         data: Dictionary;