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

package/lib/adapter.cjs

@@ -25,7 +25,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/adapter.ts
-var import_adapters = require("@forklaunch/better-auth/adapters");
+var import_core2 = require("@mikro-orm/core");
+var import_adapters = require("better-auth/adapters");
 var import_dset2 = require("dset");
 
 // src/utils/adapterUtils.ts
@@ -33,7 +34,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}`);
 }
@@ -124,10 +125,12 @@ function createAdapterUtils(orm) {
     const fields = {};
     Object.entries(input).forEach(([key, value]) => {
       if (typeof value === "object" && value.$in) {
-        (0, import_dset.dset)(fields, key, 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;
@@ -169,6 +172,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,18 +193,14 @@ 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);
       }
       return createWhereClause(path, value, "eq", result);
     });
     where.filter(({ connector }) => connector === "OR").forEach(({ field, value }, index) => {
-      const path = ["$and", index].concat(
-        getFieldPath(metadata2, field, true)
-      );
+      const path = ["$or", index].concat(getFieldPath(metadata2, field, true));
       return createWhereClause(path, value, "eq", result);
     });
     return result;
@@ -215,119 +216,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?.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)
+      );
+      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)
+      );
+    }
+  };
+};
+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)
-        );
-        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)
+    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 ?? {})
         );
-      },
-      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,7 @@
-import * as _forklaunch_better_auth from '@forklaunch/better-auth';
+import * as better_auth_adapters from 'better-auth/adapters';
+import { AdapterDebugLogs } 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 {
     /**
@@ -20,6 +21,10 @@ interface MikroOrmAdapterConfig {
      * @default true
      */
     supportsJSON?: boolean;
+    /**
+     * Options for the Better Auth adapter.
+     */
+    options?: BetterAuthOptions;
 }
 /**
  * Creates Mikro ORM adapter for Better Auth.
@@ -32,6 +37,6 @@ interface MikroOrmAdapterConfig {
  * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `MikroORM.initSync` methods
  * @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;
 
 export { type MikroOrmAdapterConfig, mikroOrmAdapter };

package/lib/adapter.d.ts

@@ -1,6 +1,7 @@
-import * as _forklaunch_better_auth from '@forklaunch/better-auth';
+import * as better_auth_adapters from 'better-auth/adapters';
+import { AdapterDebugLogs } 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 {
     /**
@@ -20,6 +21,10 @@ interface MikroOrmAdapterConfig {
      * @default true
      */
     supportsJSON?: boolean;
+    /**
+     * Options for the Better Auth adapter.
+     */
+    options?: BetterAuthOptions;
 }
 /**
  * Creates Mikro ORM adapter for Better Auth.
@@ -32,6 +37,6 @@ interface MikroOrmAdapterConfig {
  * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `MikroORM.initSync` methods
  * @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;
 
 export { type MikroOrmAdapterConfig, mikroOrmAdapter };

package/lib/adapter.js

@@ -1,7 +1,8 @@
 // src/adapter.ts
+import "@mikro-orm/core";
 import {
-  createAdapter
-} from "@forklaunch/better-auth/adapters";
+  createAdapterFactory
+} from "better-auth/adapters";
 import { dset as dset2 } from "dset";
 
 // src/utils/adapterUtils.ts
@@ -9,7 +10,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}`);
 }
@@ -100,10 +101,12 @@ function createAdapterUtils(orm) {
     const fields = {};
     Object.entries(input).forEach(([key, value]) => {
       if (typeof value === "object" && value.$in) {
-        dset(fields, key, 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;
@@ -145,6 +148,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,18 +169,14 @@ 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);
       }
       return createWhereClause(path, value, "eq", result);
     });
     where.filter(({ connector }) => connector === "OR").forEach(({ field, value }, index) => {
-      const path = ["$and", index].concat(
-        getFieldPath(metadata2, field, true)
-      );
+      const path = ["$or", index].concat(getFieldPath(metadata2, field, true));
       return createWhereClause(path, value, "eq", result);
     });
     return result;
@@ -191,119 +192,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?.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)
+      );
+      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)
+      );
+    }
+  };
+};
+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)
-        );
-        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)
+    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 ?? {})
         );
-      },
-      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.4.106",
   "description": "Mikro ORM Adapter for Better Auth",
   "keywords": [
     "auth",
@@ -59,7 +59,7 @@
     "@types/uuid": "10.0.0",
     "@vitest/coverage-v8": "3.1.1",
     "@vitest/ui": "3.1.1",
-    "@forklaunch/better-auth": "1.3.8",
+    "better-auth": "1.3.11",
     "del-cli": "6.0.0",
     "es-toolkit": "1.39.7",
     "husky": "9.1.7",

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