@forklaunch/better-auth-mikro-orm-fork 0.4.105 → 0.5.0

package/lib/adapter.cjs

@@ -25,7 +25,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/adapter.ts
-var import_adapters = require("@forklaunch/better-auth/adapters");
+var import_adapters = require("better-auth/adapters");
 var import_dset2 = require("dset");
 
 // src/utils/adapterUtils.ts
@@ -33,7 +33,7 @@ var import_core = require("@mikro-orm/core");
 var import_dset = require("dset");
 
 // src/utils/createAdapterError.ts
-var import_better_auth = require("@forklaunch/better-auth");
+var import_better_auth = require("better-auth");
 function createAdapterError(message) {
   throw new import_better_auth.BetterAuthError(`[Mikro ORM Adapter] ${message}`);
 }
@@ -50,12 +50,15 @@ function createAdapterUtils(orm) {
   const normalizeEntityName = (name) => naming.getEntityName(naming.classToTableName(name));
   const getEntityMetadata = (entityName) => {
     entityName = normalizeEntityName(entityName);
-    if (!metadata.has(entityName)) {
-      createAdapterError(
-        `Cannot find metadata for "${entityName}" entity. Make sure it defined and listed in your Mikro ORM config.`
-      );
+    const allMetadata = metadata.getAll();
+    for (const meta of allMetadata.values()) {
+      if (meta.className === entityName) {
+        return meta;
+      }
     }
-    return metadata.get(entityName);
+    createAdapterError(
+      `Cannot find metadata for "${entityName}" entity. Make sure it defined and listed in your Mikro ORM config.`
+    );
   };
   function getPropertyMetadata(metadata2, fieldName) {
     const prop = metadata2.props.find((prop2) => {
@@ -123,11 +126,13 @@ function createAdapterUtils(orm) {
   const normalizeInput = (metadata2, input) => {
     const fields = {};
     Object.entries(input).forEach(([key, value]) => {
-      if (typeof value === "object" && value.$in) {
-        (0, import_dset.dset)(fields, key, value.$in);
+      if (typeof value === "object" && value !== null && value.$in) {
+        const property = getPropertyMetadata(metadata2, key);
+        (0, import_dset.dset)(fields, [property.name], value.$in);
       } else {
-        const path = getFieldPath(metadata2, key);
-        (0, import_dset.dset)(fields, path, value);
+        const property = getPropertyMetadata(metadata2, key);
+        const normalizedValue = normalizePropertyValue(property, value);
+        (0, import_dset.dset)(fields, [property.name], normalizedValue);
       }
     });
     return fields;
@@ -141,7 +146,9 @@ function createAdapterUtils(orm) {
         getPropertyMetadata(metadata2, key)
       ),
       value
-    })).forEach(({ path, value }) => (0, import_dset.dset)(result, path, value));
+    })).forEach(({ path, value }) => {
+      (0, import_dset.dset)(result, path, value);
+    });
     return result;
   };
   function createWhereClause(path, value, op, target = {}) {
@@ -169,6 +176,8 @@ function createAdapterUtils(orm) {
       switch (w.operator) {
         case "in":
           return createWhereInClause(w.field, path, w.value);
+        case "not_in":
+          return createWhereClause(path, w.value, "$nin");
         case "contains":
           return createWhereClause(path, `%${w.value}%`, "$like");
         case "starts_with":
@@ -188,19 +197,16 @@ function createAdapterUtils(orm) {
     }
     const result = {};
     where.filter(({ connector }) => !connector || connector === "AND").forEach(({ field, operator, value }, index) => {
-      const path = ["$and", index].concat(
-        getFieldPath(metadata2, field, true)
-      );
+      const path = ["$and", index].concat(getFieldPath(metadata2, field, true));
       if (operator === "in") {
-        return createWhereInClause(field, path, value, result);
+        createWhereInClause(field, path, value, result);
+      } else {
+        createWhereClause(path, value, "eq", result);
       }
-      return createWhereClause(path, value, "eq", result);
     });
     where.filter(({ connector }) => connector === "OR").forEach(({ field, value }, index) => {
-      const path = ["$and", index].concat(
-        getFieldPath(metadata2, field, true)
-      );
-      return createWhereClause(path, value, "eq", result);
+      const path = ["$or", index].concat(getFieldPath(metadata2, field, true));
+      createWhereClause(path, value, "eq", result);
     });
     return result;
   };
@@ -215,119 +221,135 @@ function createAdapterUtils(orm) {
 }
 
 // src/adapter.ts
-var mikroOrmAdapter = (orm, { debugLogs, supportsJSON = true } = {}) => (0, import_adapters.createAdapter)({
+var adapter = (orm) => ({ options }) => {
+  const {
+    getEntityMetadata,
+    getFieldPath,
+    normalizeInput,
+    normalizeOutput,
+    normalizeWhereClauses
+  } = createAdapterUtils(orm);
+  return {
+    async create({ model, data, select }) {
+      const metadata = getEntityMetadata(model);
+      const input = normalizeInput(metadata, data);
+      if (options.advanced?.database?.generateId === false) {
+        Reflect.deleteProperty(input, "id");
+      }
+      const entity = orm.em.create(metadata.class, input);
+      try {
+        await orm.em.persist(entity).flush();
+      } catch (error) {
+        await orm.em.remove(entity).flush();
+        throw error;
+      }
+      return normalizeOutput(metadata, entity, select);
+    },
+    async count({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      return orm.em.count(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+    },
+    async findOne({ model, where, select }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      if (!entity) {
+        return null;
+      }
+      return normalizeOutput(metadata, entity, select);
+    },
+    async findMany({ model, where, limit, offset, sortBy }) {
+      const metadata = getEntityMetadata(model);
+      const options2 = {
+        limit,
+        offset
+      };
+      if (sortBy) {
+        const path = getFieldPath(metadata, sortBy.field);
+        (0, import_dset2.dset)(options2, ["orderBy", ...path], sortBy.direction);
+      }
+      const rows = await orm.em.find(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        options2
+      );
+      return rows.map((row) => normalizeOutput(metadata, row));
+    },
+    async update({ model, where, update }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      if (!entity) {
+        return null;
+      }
+      orm.em.assign(entity, normalizeInput(metadata, update));
+      try {
+        await orm.em.flush();
+      } catch (error) {
+        await orm.em.remove(entity).flush();
+        throw error;
+      }
+      return normalizeOutput(metadata, entity);
+    },
+    async updateMany({ model, where, update }) {
+      const metadata = getEntityMetadata(model);
+      return orm.em.nativeUpdate(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        normalizeInput(metadata, update)
+      );
+    },
+    async delete({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        {
+          fields: ["id"]
+        }
+      );
+      if (entity) {
+        await orm.em.remove(entity).flush();
+      }
+    },
+    async deleteMany({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      return orm.em.nativeDelete(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+    }
+  };
+};
+var mikroOrmAdapter = (orm, { debugLogs, supportsJSON = true, options } = {}) => (0, import_adapters.createAdapterFactory)({
+  adapter: adapter(orm),
   config: {
     debugLogs,
     supportsJSON,
     adapterId: "mikro-orm-adapter",
-    adapterName: "Mikro ORM Adapter"
-  },
-  adapter({ options }) {
-    const {
-      getEntityMetadata,
-      getFieldPath,
-      normalizeInput,
-      normalizeOutput,
-      normalizeWhereClauses
-    } = createAdapterUtils(orm);
-    return {
-      async create({ model, data, select }) {
-        const metadata = getEntityMetadata(model);
-        const input = normalizeInput(metadata, data);
-        if (options.advanced?.generateId === false && !options.advanced?.database || options.advanced?.database?.generateId === false) {
-          Reflect.deleteProperty(input, "id");
-        }
-        const entity = orm.em.create(metadata.class, input);
-        try {
-          await orm.em.persistAndFlush(entity);
-        } catch (error) {
-          await orm.em.removeAndFlush(entity);
-          throw error;
-        }
-        return normalizeOutput(metadata, entity, select);
-      },
-      async count({ model, where }) {
-        const metadata = getEntityMetadata(model);
-        return orm.em.count(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
-        );
-      },
-      async findOne({ model, where, select }) {
-        const metadata = getEntityMetadata(model);
-        const entity = await orm.em.findOne(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
+    adapterName: "Mikro ORM Adapter",
+    transaction: async (cb) => {
+      return orm.em.transactional(async () => {
+        return cb(
+          (0, import_adapters.createAdapterFactory)({
+            adapter: adapter(orm),
+            config: {
+              debugLogs,
+              supportsJSON,
+              adapterId: "mikro-orm-adapter-transaction",
+              adapterName: "Mikro ORM Adapter Transaction"
+            }
+          })(options ?? {})
         );
-        if (!entity) {
-          return null;
-        }
-        return normalizeOutput(metadata, entity, select);
-      },
-      async findMany({ model, where, limit, offset, sortBy }) {
-        const metadata = getEntityMetadata(model);
-        const options2 = {
-          limit,
-          offset
-        };
-        if (sortBy) {
-          const path = getFieldPath(metadata, sortBy.field);
-          (0, import_dset2.dset)(options2, ["orderBy", ...path], sortBy.direction);
-        }
-        const rows = await orm.em.find(
-          metadata.class,
-          normalizeWhereClauses(metadata, where),
-          options2
-        );
-        return rows.map((row) => normalizeOutput(metadata, row));
-      },
-      async update({ model, where, update }) {
-        const metadata = getEntityMetadata(model);
-        const entity = await orm.em.findOne(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
-        );
-        if (!entity) {
-          return null;
-        }
-        orm.em.assign(entity, normalizeInput(metadata, update));
-        try {
-          await orm.em.flush();
-        } catch (error) {
-          await orm.em.removeAndFlush(entity);
-          throw error;
-        }
-        return normalizeOutput(metadata, entity);
-      },
-      async updateMany({ model, where, update }) {
-        const metadata = getEntityMetadata(model);
-        return orm.em.nativeUpdate(
-          metadata.class,
-          normalizeWhereClauses(metadata, where),
-          normalizeInput(metadata, update)
-        );
-      },
-      async delete({ model, where }) {
-        const metadata = getEntityMetadata(model);
-        const entity = await orm.em.findOne(
-          metadata.class,
-          normalizeWhereClauses(metadata, where),
-          {
-            fields: ["id"]
-          }
-        );
-        if (entity) {
-          await orm.em.removeAndFlush(entity);
-        }
-      },
-      async deleteMany({ model, where }) {
-        const metadata = getEntityMetadata(model);
-        return orm.em.nativeDelete(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
-        );
-      }
-    };
+      });
+    }
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/lib/adapter.d.cts

@@ -1,6 +1,6 @@
-import * as _forklaunch_better_auth from '@forklaunch/better-auth';
+import * as better_auth_adapters from 'better-auth/adapters';
 import { MikroORM } from '@mikro-orm/core';
-import { AdapterDebugLogs } from '@forklaunch/better-auth/adapters';
+import { BetterAuthOptions } from 'better-auth/types';
 
 interface MikroOrmAdapterConfig {
     /**
@@ -8,7 +8,11 @@ interface MikroOrmAdapterConfig {
      *
      * @default false
      */
-    debugLogs?: AdapterDebugLogs;
+    debugLogs?: boolean | {
+        isRunningAdapterTests: boolean;
+    } | {
+        logCondition?: () => boolean;
+    };
     /**
      * Indicates whether or not JSON is supported by target database.
      *
@@ -20,6 +24,10 @@ interface MikroOrmAdapterConfig {
      * @default true
      */
     supportsJSON?: boolean;
+    /**
+     * Options for the Better Auth adapter.
+     */
+    options?: BetterAuthOptions;
 }
 /**
  * Creates Mikro ORM adapter for Better Auth.
@@ -29,9 +37,9 @@ interface MikroOrmAdapterConfig {
  *   * No complex primary key support
  *   * No schema generation
  *
- * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `MikroORM.initSync` methods
+ * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `new MikroORM` constructor
  * @param config - Additional configuration for Mikro ORM adapter
  */
-declare const mikroOrmAdapter: (orm: MikroORM, { debugLogs, supportsJSON }?: MikroOrmAdapterConfig) => (options: _forklaunch_better_auth.BetterAuthOptions) => _forklaunch_better_auth.Adapter;
+declare const mikroOrmAdapter: (orm: MikroORM, { debugLogs, supportsJSON, options }?: MikroOrmAdapterConfig) => better_auth_adapters.AdapterFactory<BetterAuthOptions>;
 
 export { type MikroOrmAdapterConfig, mikroOrmAdapter };

package/lib/adapter.d.ts

@@ -1,6 +1,6 @@
-import * as _forklaunch_better_auth from '@forklaunch/better-auth';
+import * as better_auth_adapters from 'better-auth/adapters';
 import { MikroORM } from '@mikro-orm/core';
-import { AdapterDebugLogs } from '@forklaunch/better-auth/adapters';
+import { BetterAuthOptions } from 'better-auth/types';
 
 interface MikroOrmAdapterConfig {
     /**
@@ -8,7 +8,11 @@ interface MikroOrmAdapterConfig {
      *
      * @default false
      */
-    debugLogs?: AdapterDebugLogs;
+    debugLogs?: boolean | {
+        isRunningAdapterTests: boolean;
+    } | {
+        logCondition?: () => boolean;
+    };
     /**
      * Indicates whether or not JSON is supported by target database.
      *
@@ -20,6 +24,10 @@ interface MikroOrmAdapterConfig {
      * @default true
      */
     supportsJSON?: boolean;
+    /**
+     * Options for the Better Auth adapter.
+     */
+    options?: BetterAuthOptions;
 }
 /**
  * Creates Mikro ORM adapter for Better Auth.
@@ -29,9 +37,9 @@ interface MikroOrmAdapterConfig {
  *   * No complex primary key support
  *   * No schema generation
  *
- * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `MikroORM.initSync` methods
+ * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `new MikroORM` constructor
  * @param config - Additional configuration for Mikro ORM adapter
  */
-declare const mikroOrmAdapter: (orm: MikroORM, { debugLogs, supportsJSON }?: MikroOrmAdapterConfig) => (options: _forklaunch_better_auth.BetterAuthOptions) => _forklaunch_better_auth.Adapter;
+declare const mikroOrmAdapter: (orm: MikroORM, { debugLogs, supportsJSON, options }?: MikroOrmAdapterConfig) => better_auth_adapters.AdapterFactory<BetterAuthOptions>;
 
 export { type MikroOrmAdapterConfig, mikroOrmAdapter };

package/lib/adapter.js

@@ -1,7 +1,7 @@
 // src/adapter.ts
 import {
-  createAdapter
-} from "@forklaunch/better-auth/adapters";
+  createAdapterFactory
+} from "better-auth/adapters";
 import { dset as dset2 } from "dset";
 
 // src/utils/adapterUtils.ts
@@ -9,7 +9,7 @@ import { ReferenceKind, serialize } from "@mikro-orm/core";
 import { dset } from "dset";
 
 // src/utils/createAdapterError.ts
-import { BetterAuthError } from "@forklaunch/better-auth";
+import { BetterAuthError } from "better-auth";
 function createAdapterError(message) {
   throw new BetterAuthError(`[Mikro ORM Adapter] ${message}`);
 }
@@ -26,12 +26,15 @@ function createAdapterUtils(orm) {
   const normalizeEntityName = (name) => naming.getEntityName(naming.classToTableName(name));
   const getEntityMetadata = (entityName) => {
     entityName = normalizeEntityName(entityName);
-    if (!metadata.has(entityName)) {
-      createAdapterError(
-        `Cannot find metadata for "${entityName}" entity. Make sure it defined and listed in your Mikro ORM config.`
-      );
+    const allMetadata = metadata.getAll();
+    for (const meta of allMetadata.values()) {
+      if (meta.className === entityName) {
+        return meta;
+      }
     }
-    return metadata.get(entityName);
+    createAdapterError(
+      `Cannot find metadata for "${entityName}" entity. Make sure it defined and listed in your Mikro ORM config.`
+    );
   };
   function getPropertyMetadata(metadata2, fieldName) {
     const prop = metadata2.props.find((prop2) => {
@@ -99,11 +102,13 @@ function createAdapterUtils(orm) {
   const normalizeInput = (metadata2, input) => {
     const fields = {};
     Object.entries(input).forEach(([key, value]) => {
-      if (typeof value === "object" && value.$in) {
-        dset(fields, key, value.$in);
+      if (typeof value === "object" && value !== null && value.$in) {
+        const property = getPropertyMetadata(metadata2, key);
+        dset(fields, [property.name], value.$in);
       } else {
-        const path = getFieldPath(metadata2, key);
-        dset(fields, path, value);
+        const property = getPropertyMetadata(metadata2, key);
+        const normalizedValue = normalizePropertyValue(property, value);
+        dset(fields, [property.name], normalizedValue);
       }
     });
     return fields;
@@ -117,7 +122,9 @@ function createAdapterUtils(orm) {
         getPropertyMetadata(metadata2, key)
       ),
       value
-    })).forEach(({ path, value }) => dset(result, path, value));
+    })).forEach(({ path, value }) => {
+      dset(result, path, value);
+    });
     return result;
   };
   function createWhereClause(path, value, op, target = {}) {
@@ -145,6 +152,8 @@ function createAdapterUtils(orm) {
       switch (w.operator) {
         case "in":
           return createWhereInClause(w.field, path, w.value);
+        case "not_in":
+          return createWhereClause(path, w.value, "$nin");
         case "contains":
           return createWhereClause(path, `%${w.value}%`, "$like");
         case "starts_with":
@@ -164,19 +173,16 @@ function createAdapterUtils(orm) {
     }
     const result = {};
     where.filter(({ connector }) => !connector || connector === "AND").forEach(({ field, operator, value }, index) => {
-      const path = ["$and", index].concat(
-        getFieldPath(metadata2, field, true)
-      );
+      const path = ["$and", index].concat(getFieldPath(metadata2, field, true));
       if (operator === "in") {
-        return createWhereInClause(field, path, value, result);
+        createWhereInClause(field, path, value, result);
+      } else {
+        createWhereClause(path, value, "eq", result);
       }
-      return createWhereClause(path, value, "eq", result);
     });
     where.filter(({ connector }) => connector === "OR").forEach(({ field, value }, index) => {
-      const path = ["$and", index].concat(
-        getFieldPath(metadata2, field, true)
-      );
-      return createWhereClause(path, value, "eq", result);
+      const path = ["$or", index].concat(getFieldPath(metadata2, field, true));
+      createWhereClause(path, value, "eq", result);
     });
     return result;
   };
@@ -191,119 +197,135 @@ function createAdapterUtils(orm) {
 }
 
 // src/adapter.ts
-var mikroOrmAdapter = (orm, { debugLogs, supportsJSON = true } = {}) => createAdapter({
+var adapter = (orm) => ({ options }) => {
+  const {
+    getEntityMetadata,
+    getFieldPath,
+    normalizeInput,
+    normalizeOutput,
+    normalizeWhereClauses
+  } = createAdapterUtils(orm);
+  return {
+    async create({ model, data, select }) {
+      const metadata = getEntityMetadata(model);
+      const input = normalizeInput(metadata, data);
+      if (options.advanced?.database?.generateId === false) {
+        Reflect.deleteProperty(input, "id");
+      }
+      const entity = orm.em.create(metadata.class, input);
+      try {
+        await orm.em.persist(entity).flush();
+      } catch (error) {
+        await orm.em.remove(entity).flush();
+        throw error;
+      }
+      return normalizeOutput(metadata, entity, select);
+    },
+    async count({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      return orm.em.count(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+    },
+    async findOne({ model, where, select }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      if (!entity) {
+        return null;
+      }
+      return normalizeOutput(metadata, entity, select);
+    },
+    async findMany({ model, where, limit, offset, sortBy }) {
+      const metadata = getEntityMetadata(model);
+      const options2 = {
+        limit,
+        offset
+      };
+      if (sortBy) {
+        const path = getFieldPath(metadata, sortBy.field);
+        dset2(options2, ["orderBy", ...path], sortBy.direction);
+      }
+      const rows = await orm.em.find(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        options2
+      );
+      return rows.map((row) => normalizeOutput(metadata, row));
+    },
+    async update({ model, where, update }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      if (!entity) {
+        return null;
+      }
+      orm.em.assign(entity, normalizeInput(metadata, update));
+      try {
+        await orm.em.flush();
+      } catch (error) {
+        await orm.em.remove(entity).flush();
+        throw error;
+      }
+      return normalizeOutput(metadata, entity);
+    },
+    async updateMany({ model, where, update }) {
+      const metadata = getEntityMetadata(model);
+      return orm.em.nativeUpdate(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        normalizeInput(metadata, update)
+      );
+    },
+    async delete({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        {
+          fields: ["id"]
+        }
+      );
+      if (entity) {
+        await orm.em.remove(entity).flush();
+      }
+    },
+    async deleteMany({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      return orm.em.nativeDelete(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+    }
+  };
+};
+var mikroOrmAdapter = (orm, { debugLogs, supportsJSON = true, options } = {}) => createAdapterFactory({
+  adapter: adapter(orm),
   config: {
     debugLogs,
     supportsJSON,
     adapterId: "mikro-orm-adapter",
-    adapterName: "Mikro ORM Adapter"
-  },
-  adapter({ options }) {
-    const {
-      getEntityMetadata,
-      getFieldPath,
-      normalizeInput,
-      normalizeOutput,
-      normalizeWhereClauses
-    } = createAdapterUtils(orm);
-    return {
-      async create({ model, data, select }) {
-        const metadata = getEntityMetadata(model);
-        const input = normalizeInput(metadata, data);
-        if (options.advanced?.generateId === false && !options.advanced?.database || options.advanced?.database?.generateId === false) {
-          Reflect.deleteProperty(input, "id");
-        }
-        const entity = orm.em.create(metadata.class, input);
-        try {
-          await orm.em.persistAndFlush(entity);
-        } catch (error) {
-          await orm.em.removeAndFlush(entity);
-          throw error;
-        }
-        return normalizeOutput(metadata, entity, select);
-      },
-      async count({ model, where }) {
-        const metadata = getEntityMetadata(model);
-        return orm.em.count(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
-        );
-      },
-      async findOne({ model, where, select }) {
-        const metadata = getEntityMetadata(model);
-        const entity = await orm.em.findOne(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
+    adapterName: "Mikro ORM Adapter",
+    transaction: async (cb) => {
+      return orm.em.transactional(async () => {
+        return cb(
+          createAdapterFactory({
+            adapter: adapter(orm),
+            config: {
+              debugLogs,
+              supportsJSON,
+              adapterId: "mikro-orm-adapter-transaction",
+              adapterName: "Mikro ORM Adapter Transaction"
+            }
+          })(options ?? {})
         );
-        if (!entity) {
-          return null;
-        }
-        return normalizeOutput(metadata, entity, select);
-      },
-      async findMany({ model, where, limit, offset, sortBy }) {
-        const metadata = getEntityMetadata(model);
-        const options2 = {
-          limit,
-          offset
-        };
-        if (sortBy) {
-          const path = getFieldPath(metadata, sortBy.field);
-          dset2(options2, ["orderBy", ...path], sortBy.direction);
-        }
-        const rows = await orm.em.find(
-          metadata.class,
-          normalizeWhereClauses(metadata, where),
-          options2
-        );
-        return rows.map((row) => normalizeOutput(metadata, row));
-      },
-      async update({ model, where, update }) {
-        const metadata = getEntityMetadata(model);
-        const entity = await orm.em.findOne(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
-        );
-        if (!entity) {
-          return null;
-        }
-        orm.em.assign(entity, normalizeInput(metadata, update));
-        try {
-          await orm.em.flush();
-        } catch (error) {
-          await orm.em.removeAndFlush(entity);
-          throw error;
-        }
-        return normalizeOutput(metadata, entity);
-      },
-      async updateMany({ model, where, update }) {
-        const metadata = getEntityMetadata(model);
-        return orm.em.nativeUpdate(
-          metadata.class,
-          normalizeWhereClauses(metadata, where),
-          normalizeInput(metadata, update)
-        );
-      },
-      async delete({ model, where }) {
-        const metadata = getEntityMetadata(model);
-        const entity = await orm.em.findOne(
-          metadata.class,
-          normalizeWhereClauses(metadata, where),
-          {
-            fields: ["id"]
-          }
-        );
-        if (entity) {
-          await orm.em.removeAndFlush(entity);
-        }
-      },
-      async deleteMany({ model, where }) {
-        const metadata = getEntityMetadata(model);
-        return orm.em.nativeDelete(
-          metadata.class,
-          normalizeWhereClauses(metadata, where)
-        );
-      }
-    };
+      });
+    }
   }
 });
 export {

package/package.json

@@ -2,7 +2,7 @@
   "private": false,
   "type": "module",
   "name": "@forklaunch/better-auth-mikro-orm-fork",
-  "version": "0.4.105",
+  "version": "0.5.0",
   "description": "Mikro ORM Adapter for Better Auth",
   "keywords": [
     "auth",
@@ -20,7 +20,7 @@
     "url": "git+ssh://git@github.com/octet-stream/better-auth-mikro-orm.git"
   },
   "engines": {
-    "node": ">= 18"
+    "node": ">= 22.17"
   },
   "types": "./lib/adapter.d.cts",
   "main": "./lib/adapter.cjs",
@@ -46,34 +46,35 @@
     "lib"
   ],
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@changesets/changelog-github": "0.5.1",
-    "@changesets/cli": "2.29.2",
-    "@commitlint/cli": "19.8.0",
-    "@commitlint/config-conventional": "19.8.0",
-    "@commitlint/types": "19.8.0",
-    "@faker-js/faker": "9.7.0",
-    "@mikro-orm/better-sqlite": "6.4.13",
-    "@mikro-orm/core": "6.4.13",
-    "@types/node": "22.14.1",
-    "@types/uuid": "10.0.0",
-    "@vitest/coverage-v8": "3.1.1",
-    "@vitest/ui": "3.1.1",
-    "@forklaunch/better-auth": "1.3.8",
-    "del-cli": "6.0.0",
-    "es-toolkit": "1.39.7",
+    "@better-auth/test-utils": "1.5.5",
+    "@biomejs/biome": "2.4.7",
+    "@changesets/changelog-github": "0.6.0",
+    "@changesets/cli": "2.30.0",
+    "@commitlint/cli": "20.5.0",
+    "@commitlint/config-conventional": "20.5.0",
+    "@commitlint/types": "20.5.0",
+    "@faker-js/faker": "10.3.0",
+    "@mikro-orm/core": "7.0.2",
+    "@mikro-orm/sqlite": "7.0.2",
+    "@types/node": "25.5.0",
+    "@types/uuid": "11.0.0",
+    "@vitest/coverage-v8": "4.1.0",
+    "@vitest/ui": "4.1.0",
+    "better-auth": "1.5.5",
+    "del-cli": "7.0.0",
+    "es-toolkit": "1.45.1",
     "husky": "9.1.7",
-    "is-in-ci": "1.0.0",
-    "tsup": "8.4.0",
-    "typescript": "5.8.3",
-    "uuid": "11.1.0",
-    "vitest": "3.1.1"
+    "is-in-ci": "2.0.0",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "uuid": "13.0.0",
+    "vitest": "4.1.0"
   },
   "dependencies": {
     "dset": "3.1.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^6.0.0",
+    "@mikro-orm/core": "^7.0.0",
     "better-auth": "^1.0.0"
   },
   "scripts": {

package/readme.md

@@ -32,8 +32,8 @@ pnpm add better-auth-mikro-orm
 2. When you're finished with the schema definitions, you can simply pass the result of the `mikroOrmAdapter` call to the `database` option like this:
 
 ```ts
-import { mikroOrmAdapter } from "@forklaunch/better-auth-mikro-orm";
-import { betterAuth } from "@forklaunch/better-auth";
+import { mikroOrmAdapter } from "better-auth-mikro-orm";
+import { betterAuth } from "better-auth";
 
 import { orm } from "./orm.js"; // Your Mikro ORM instance