feat: update Resource class so that it no longer requires static orm attribute

Author: dziraf

README.md

@@ -31,17 +31,13 @@ const setupAdminJs = async () => {
     clientUrl: process.env.DATABASE_URL,
   });
 
-  // MikroORM exposes it's entity manager through created ORM instance (`orm.em`) and it's required for
-  // the adapter to run database queries. The static method `Resource.setORM` extracts required properties from your
-  // ORM instance.
-  Resource.setORM(orm);
   // If your entities use `class-validator` to validate data, you can inject it's validate method into the resource.
   Resource.validate = validate;
   AdminJS.registerAdapter({ Database, Resource });
 
   // You can instantiate AdminJS either by specifying all resources separately:
   const adminJs = new AdminJS({
-    resources: [{ resource: User, options: {} }],
+    resources: [{ resource: { model: User, orm }, options: {} }],
   });
 
   // Or by passing your ORM instance into `databases` property.

example-app/package.json

@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "@adminjs/express": "^4.0.0",
+    "@adminjs/mikroorm": "^1.0.0",
     "@mikro-orm/core": "^4.5.0",
     "@mikro-orm/postgresql": "^4.5.0",
     "adminjs": "^5.2.2",

example-app/src/index.ts

@@ -24,14 +24,13 @@ const run = async () => {
     debug: true,
   });
 
-  Resource.setORM(orm as any);
   AdminJS.registerAdapter({ Database, Resource });
 
   const app = express();
 
   const resources = [
     {
-      resource: User,
+      resource: { model: User, orm },
       options: {
         properties: {
           firstName: {
@@ -41,7 +40,7 @@ const run = async () => {
       },
     },
     {
-      resource: Car,
+      resource: { model: Car, orm },
       options: {
         properties: {
           meta: { type: 'mixed' },
@@ -54,7 +53,7 @@ const run = async () => {
         },
       },
     },
-    Seller,
+    { model: Seller, orm },
   ];
 
   const admin = new AdminJS({

spec/Property.spec.ts

@@ -17,8 +17,7 @@ describe('Property', () => {
 
   beforeAll(async () => {
     orm = await initORM();
-    Resource.setORM(orm);
-    resource = new Resource(Car);
+    resource = new Resource({ model: Car, orm });
     properties = resource.properties();
   });
 

spec/Resource.spec.ts

@@ -25,7 +25,7 @@ describe('Resource', () => {
   });
 
   beforeEach(async () => {
-    resource = new Resource(Car);
+    resource = new Resource({ model: Car, orm });
 
     await orm.em.getRepository(Car).nativeDelete({});
     await orm.em.getRepository(User).nativeDelete({});
@@ -38,16 +38,14 @@ describe('Resource', () => {
 
   describe('.isAdapterFor', () => {
     it('returns false if `orm` is not set before', () => {
-      expect(Resource.isAdapterFor(Car)).toEqual(false);
+      expect(Resource.isAdapterFor(Car as any)).toEqual(false);
     });
 
-    it('returns true when Entity is given and `orm` is set', () => {
-      Resource.setORM(orm);
-      expect(Resource.isAdapterFor(Car)).toEqual(true);
+    it('returns true when correct args are given', () => {
+      expect(Resource.isAdapterFor({ model: Car, orm })).toEqual(true);
     });
 
     it('returns false for any other kind of resources', () => {
-      Resource.setORM(orm);
       expect(Resource.isAdapterFor({ Car: true } as any)).toEqual(false);
     });
   });

src/Database.ts

@@ -14,16 +14,18 @@ export class Database extends BaseDatabase {
     if (!metadata) return [];
     metadata.decorate(this.orm.em);
 
-    Resource.setORM(this.orm);
     return Object.values(metadata.getAll()).reduce((memo: Resource[], meta) => {
-      const resource = new Resource(meta.class);
+      const resource = new Resource({
+        model: meta.class,
+        orm: this.orm,
+      });
       memo.push(resource);
 
       return memo;
     }, []);
   }
 
   public static isAdapterFor(orm: MikroORM): boolean {
-    return !!orm.isConnected && orm.isConnected() && !!orm.getMetadata();
+    return !!orm.isConnected?.() && !!orm.getMetadata?.();
   }
 }

src/Resource.ts

@@ -21,38 +21,36 @@ export type AdapterORM = {
   metadata: MetadataStorage;
 };
 
-// eslint-disable-next-line max-len
-const OrmNotFoundError = 'ORM is not set. Make sure to set it before registering the adapter: AdminJS.setORM(mikroOrmInstance)';
-
 export class Resource extends BaseResource {
-  public static orm: AdapterORM;
-
   public static validate: any;
 
-  private metadata: EntityMetadata | undefined;
+  private orm: MikroORM;
+
+  private metadata?: EntityMetadata;
 
   private model: EntityClass<AnyEntity>;
 
   private propertiesObject: Record<string, Property>;
 
-  constructor(model: EntityClass<AnyEntity>) {
-    super(model);
+  constructor(args: { model: EntityClass<AnyEntity>, orm: MikroORM }) {
+    super(args);
+
+    const { model, orm } = args;
+    this.orm = orm;
     this.model = model;
-    this.metadata = Resource.orm?.metadata?.find(model.name);
+    this.metadata = this.orm.getMetadata().find(model.name);
     this.propertiesObject = this.prepareProperties();
   }
 
-  public static setORM(orm: MikroORM) {
-    orm.getMetadata().decorate(orm.em);
-    Resource.orm = Resource.stripOrmConfig(orm);
-  }
-
   public databaseName(): string {
-    return Resource.orm?.database || 'mikroorm';
+    const {
+      database,
+    } = this.orm.config.getDriver().getConnection().getConnectionOptions();
+    return database || 'mikroorm';
   }
 
   public databaseType(): string {
-    return Resource.orm?.databaseType || this.databaseName();
+    return this.orm.config.getAll().type || this.databaseName();
   }
 
   public name(): string {
@@ -76,20 +74,16 @@ export class Resource extends BaseResource {
   }
 
   public async count(filter: Filter): Promise<number> {
-    if (!Resource.orm) throw new Error(OrmNotFoundError);
-
-    return Resource.orm.entityManager.getRepository(this.model).count(
+    return this.orm.em.getRepository(this.model).count(
       convertFilter(filter),
     );
   }
 
   public async find(filter: Filter, params: Record<string, any> = {}): Promise<Array<BaseRecord>> {
-    if (!Resource.orm) throw new Error(OrmNotFoundError);
-
     const { limit = 10, offset = 0, sort = {} } = params;
     const { direction, sortBy } = sort as { direction: 'asc' | 'desc', sortBy: string };
 
-    const results = await Resource.orm.entityManager
+    const results = await this.orm.em
       .getRepository(this.model)
       .find(
         convertFilter(filter), {
@@ -105,11 +99,9 @@ export class Resource extends BaseResource {
   }
 
   public async findOne(id: string | number): Promise<BaseRecord | null> {
-    if (!Resource.orm) throw new Error(OrmNotFoundError);
-
-    const result = await Resource.orm.entityManager
+    const result = await this.orm.em
       .getRepository(this.model)
-      .findOne(id as any); // mikroorm has incorrect types for findOne
+      .findOne(id as any); // mikroorm has incorrect types for `findOne`
 
     if (!result) return null;
 
@@ -119,22 +111,18 @@ export class Resource extends BaseResource {
   public async findMany(
     ids: Array<string | number>,
   ): Promise<Array<BaseRecord>> {
-    if (!Resource.orm) throw new Error(OrmNotFoundError);
-
     const pk = this.metadata?.primaryKeys[0];
     if (!pk) return [];
 
-    const results = await Resource.orm.entityManager
+    const results = await this.orm.em
       .getRepository(this.model)
       .find({ [pk]: { $in: ids } });
 
     return results.map((result) => new BaseRecord(wrap(result).toJSON(), this));
   }
 
   public async create(params: Record<string, any>): Promise<Record<string, any>> {
-    if (!Resource.orm) throw new Error(OrmNotFoundError);
-
-    const instance = Resource.orm?.entityManager
+    const instance = this.orm.em
       .getRepository(this.model)
       .create(flat.unflatten(params));
 
@@ -146,9 +134,7 @@ export class Resource extends BaseResource {
   }
 
   public async update(pk: string | number, params: Record<string, any> = {}): Promise<Record<string, any>> {
-    if (!Resource.orm) throw new Error(OrmNotFoundError);
-
-    const instance = await Resource.orm?.entityManager
+    const instance = await this.orm.em
       .getRepository(this.model)
       .findOne(pk as any); // mikroorm has incorrect types for findOneOrFail
 
@@ -164,32 +150,15 @@ export class Resource extends BaseResource {
   }
 
   public async delete(id: string | number): Promise<void> {
-    if (!Resource.orm) return;
-
-    await Resource.orm?.entityManager
+    await this.orm.em
       .getRepository(this.model)
       .nativeDelete(id as any); // mikroorm has incorrect types for nativeDelete
   }
 
-  public static isAdapterFor(rawResource: EntityClass<AnyEntity>): boolean {
-    try {
-      if (Resource.orm === null) return false;
-      const metadata = Resource.orm?.metadata?.find(rawResource.name);
-      return !!metadata;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  public static stripOrmConfig(orm: MikroORM) {
-    const {
-      database,
-    } = orm.config.getDriver().getConnection().getConnectionOptions();
-    const databaseType = orm.config.getAll().type;
-    const entityManager = orm.em;
-    const metadata = orm.getMetadata();
+  public static isAdapterFor(args?: { model?: EntityClass<AnyEntity>, orm?: MikroORM }): boolean {
+    const { model, orm } = args ?? {};
 
-    return { database, databaseType, entityManager, metadata };
+    return !!model?.name && !!orm?.getMetadata?.().find?.(model.name);
   }
 
   async validateAndSave(instance: Loaded<AnyEntity>): Promise<void> {
@@ -210,7 +179,7 @@ export class Resource extends BaseResource {
       }
     }
     try {
-      await Resource.orm?.entityManager.persistAndFlush(instance);
+      await this.orm.em.persistAndFlush(instance);
     } catch (error) {
       if (error.name === 'QueryFailedError') {
         throw new ValidationError({