@forklaunch/better-auth-mikro-orm-fork 0.3.0

package/lib/adapter.cjs

@@ -0,0 +1,313 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  mikroOrmAdapter: () => mikroOrmAdapter
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/adapter.ts
+var import_better_auth2 = require("better-auth");
+var import_dset2 = require("dset");
+
+// src/utils/adapterUtils.ts
+var import_core = require("@mikro-orm/core");
+var import_dset = require("dset");
+
+// src/utils/createAdapterError.ts
+var import_better_auth = require("better-auth");
+function createAdapterError(message) {
+  throw new import_better_auth.BetterAuthError(`[Mikro ORM Adapter] ${message}`);
+}
+
+// src/utils/adapterUtils.ts
+var ownReferences = [import_core.ReferenceKind.SCALAR, import_core.ReferenceKind.ONE_TO_MANY];
+function createAdapterUtils(orm) {
+  const naming = orm.config.getNamingStrategy();
+  const metadata = orm.getMetadata();
+  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.`
+      );
+    }
+    return metadata.get(entityName);
+  };
+  function getPropertyMetadata(metadata2, fieldName) {
+    const prop = metadata2.props.find((prop2) => {
+      if (ownReferences.includes(prop2.kind) && prop2.name === fieldName) {
+        return true;
+      }
+      if (prop2.kind === import_core.ReferenceKind.MANY_TO_ONE && (prop2.name === fieldName || prop2.fieldNames.includes(naming.propertyToColumnName(fieldName)))) {
+        return true;
+      }
+      if (prop2.kind === import_core.ReferenceKind.MANY_TO_MANY && (prop2.name === fieldName || prop2.fieldNames.includes(naming.propertyToColumnName(fieldName)))) {
+        return true;
+      }
+      return false;
+    });
+    if (!prop) {
+      createAdapterError(
+        `Can't find property "${fieldName}" on entity "${metadata2.className}".`
+      );
+    }
+    return prop;
+  }
+  function getReferencedColumnName(entityName, prop) {
+    if (ownReferences.includes(prop.kind)) {
+      return prop.name;
+    }
+    if (prop.kind === import_core.ReferenceKind.MANY_TO_ONE) {
+      return naming.joinColumnName(prop.name);
+    }
+    if (prop.kind === import_core.ReferenceKind.MANY_TO_MANY) {
+      return prop.name;
+    }
+    createAdapterError(
+      `Reference kind ${prop.kind} is not supported. Defined in "${entityName}" entity for "${prop.name}" field.`
+    );
+  }
+  const getReferencedPropertyName = (metadata2, prop) => naming.columnNameToProperty(
+    getReferencedColumnName(metadata2.className, prop)
+  );
+  const getFieldPath = (metadata2, fieldName, throwOnShadowProps = false) => {
+    const prop = getPropertyMetadata(metadata2, fieldName);
+    if (prop.persist === false && throwOnShadowProps) {
+      createAdapterError(
+        `Cannot serialize "${fieldName}" into path, because it cannot be persisted in "${metadata2.tableName}" table.`
+      );
+    }
+    if (prop.kind === import_core.ReferenceKind.SCALAR) {
+      return [prop.name];
+    }
+    if (prop.kind === import_core.ReferenceKind.MANY_TO_ONE) {
+      if (prop.referencedPKs.length > 1) {
+        createAdapterError(
+          `The "${fieldName}" field references to a table "${prop.name}" with complex primary key, which is not supported`
+        );
+      }
+      return [prop.name, naming.referenceColumnName()];
+    }
+    createAdapterError(
+      `Cannot normalize "${fieldName}" field name into path for "${metadata2.className} entity."`
+    );
+  };
+  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"]);
+      } else {
+        const path = getFieldPath(metadata2, key);
+        (0, import_dset.dset)(fields, path, value);
+      }
+    });
+    return fields;
+  };
+  const normalizeOutput = (metadata2, output, select) => {
+    output = (0, import_core.serialize)(output);
+    const result = {};
+    Object.entries(output).map(([key, value]) => ({
+      path: getReferencedPropertyName(
+        metadata2,
+        getPropertyMetadata(metadata2, key)
+      ),
+      value
+    })).filter(({ path }) => select ? select.includes(path) : true).forEach(({ path, value }) => (0, import_dset.dset)(result, path, value));
+    return result;
+  };
+  function createWhereClause(path, value, op, target = {}) {
+    (0, import_dset.dset)(target, op == null || op === "eq" ? path : path.concat(op), value);
+    return target;
+  }
+  function createWhereInClause(fieldName, path, value, target) {
+    if (!Array.isArray(value)) {
+      createAdapterError(
+        `The value for the field "${fieldName}" must be an array when using the $in operator.`
+      );
+    }
+    return createWhereClause(path, value, "$in", target);
+  }
+  const normalizeWhereClauses = (metadata2, where) => {
+    if (!where) {
+      return {};
+    }
+    if (where.length === 1) {
+      const [w] = where;
+      if (!w) {
+        return {};
+      }
+      const path = getFieldPath(metadata2, w.field, true);
+      switch (w.operator) {
+        case "in":
+          return createWhereInClause(w.field, path, w.value);
+        case "contains":
+          return createWhereClause(path, `%${w.value}%`, "$like");
+        case "starts_with":
+          return createWhereClause(path, `${w.value}%`, "$like");
+        case "ends_with":
+          return createWhereClause(path, `%${w.value}`, "$like");
+        // The next 5 case statemets are _expected_ to fall through so we can simplify and reuse the same logic for these operators
+        case "gt":
+        case "gte":
+        case "lt":
+        case "lte":
+        case "ne":
+          return createWhereClause(path, w.value, `$${w.operator}`);
+        default:
+          return createWhereClause(path, w.value);
+      }
+    }
+    const result = {};
+    where.filter(({ connector }) => !connector || connector === "AND").forEach(({ field, operator, value }, index) => {
+      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)
+      );
+      return createWhereClause(path, value, "eq", result);
+    });
+    return result;
+  };
+  return {
+    getEntityMetadata,
+    normalizeEntityName,
+    getFieldPath,
+    normalizeInput,
+    normalizeOutput,
+    normalizeWhereClauses
+  };
+}
+
+// src/adapter.ts
+function mikroOrmAdapter(orm) {
+  const {
+    getEntityMetadata,
+    getFieldPath,
+    normalizeInput,
+    normalizeOutput,
+    normalizeWhereClauses
+  } = createAdapterUtils(orm);
+  const adapter = (options = {}) => ({
+    id: "mikro-orm",
+    async create({ model, data, select }) {
+      const metadata = getEntityMetadata(model);
+      const input = normalizeInput(metadata, data);
+      if (options.advanced?.generateId !== false) {
+        input.id = typeof options.advanced?.generateId === "function" ? options.advanced.generateId({ model }) : (0, import_better_auth2.generateId)();
+      }
+      const entity = orm.em.create(metadata.class, input);
+      await orm.em.persistAndFlush(entity);
+      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));
+      await orm.em.flush();
+      return normalizeOutput(metadata, entity);
+    },
+    async updateMany({ model, where, update }) {
+      const metadata = getEntityMetadata(model);
+      const affected = await orm.em.nativeUpdate(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        normalizeInput(metadata, update)
+      );
+      orm.em.clear();
+      return affected;
+    },
+    async delete({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      if (entity) {
+        await orm.em.removeAndFlush(entity);
+      }
+    },
+    async deleteMany({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      const affected = await orm.em.nativeDelete(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      orm.em.clear();
+      return affected;
+    }
+  });
+  return adapter;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mikroOrmAdapter
+});

package/lib/adapter.d.cts

@@ -0,0 +1,15 @@
+import { MikroORM } from '@mikro-orm/core';
+import { BetterAuthOptions, Adapter } from 'better-auth';
+
+/**
+ * Creates Mikro ORM adapter for Better Auth.
+ *
+ * Current limitations:
+ *   * No m:m and 1:m and embedded references support
+ *   * No complex primary key support
+ *
+ * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `MikroORM.initSync` methods
+ */
+declare function mikroOrmAdapter(orm: MikroORM): (options?: BetterAuthOptions) => Adapter;
+
+export { mikroOrmAdapter };

package/lib/adapter.d.ts

@@ -0,0 +1,15 @@
+import { MikroORM } from '@mikro-orm/core';
+import { BetterAuthOptions, Adapter } from 'better-auth';
+
+/**
+ * Creates Mikro ORM adapter for Better Auth.
+ *
+ * Current limitations:
+ *   * No m:m and 1:m and embedded references support
+ *   * No complex primary key support
+ *
+ * @param orm - Instance of Mikro ORM returned from `MikroORM.init` or `MikroORM.initSync` methods
+ */
+declare function mikroOrmAdapter(orm: MikroORM): (options?: BetterAuthOptions) => Adapter;
+
+export { mikroOrmAdapter };

package/lib/adapter.js

@@ -0,0 +1,286 @@
+// src/adapter.ts
+import { generateId } from "better-auth";
+import { dset as dset2 } from "dset";
+
+// src/utils/adapterUtils.ts
+import { ReferenceKind, serialize } from "@mikro-orm/core";
+import { dset } from "dset";
+
+// src/utils/createAdapterError.ts
+import { BetterAuthError } from "better-auth";
+function createAdapterError(message) {
+  throw new BetterAuthError(`[Mikro ORM Adapter] ${message}`);
+}
+
+// src/utils/adapterUtils.ts
+var ownReferences = [ReferenceKind.SCALAR, ReferenceKind.ONE_TO_MANY];
+function createAdapterUtils(orm) {
+  const naming = orm.config.getNamingStrategy();
+  const metadata = orm.getMetadata();
+  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.`
+      );
+    }
+    return metadata.get(entityName);
+  };
+  function getPropertyMetadata(metadata2, fieldName) {
+    const prop = metadata2.props.find((prop2) => {
+      if (ownReferences.includes(prop2.kind) && prop2.name === fieldName) {
+        return true;
+      }
+      if (prop2.kind === ReferenceKind.MANY_TO_ONE && (prop2.name === fieldName || prop2.fieldNames.includes(naming.propertyToColumnName(fieldName)))) {
+        return true;
+      }
+      if (prop2.kind === ReferenceKind.MANY_TO_MANY && (prop2.name === fieldName || prop2.fieldNames.includes(naming.propertyToColumnName(fieldName)))) {
+        return true;
+      }
+      return false;
+    });
+    if (!prop) {
+      createAdapterError(
+        `Can't find property "${fieldName}" on entity "${metadata2.className}".`
+      );
+    }
+    return prop;
+  }
+  function getReferencedColumnName(entityName, prop) {
+    if (ownReferences.includes(prop.kind)) {
+      return prop.name;
+    }
+    if (prop.kind === ReferenceKind.MANY_TO_ONE) {
+      return naming.joinColumnName(prop.name);
+    }
+    if (prop.kind === ReferenceKind.MANY_TO_MANY) {
+      return prop.name;
+    }
+    createAdapterError(
+      `Reference kind ${prop.kind} is not supported. Defined in "${entityName}" entity for "${prop.name}" field.`
+    );
+  }
+  const getReferencedPropertyName = (metadata2, prop) => naming.columnNameToProperty(
+    getReferencedColumnName(metadata2.className, prop)
+  );
+  const getFieldPath = (metadata2, fieldName, throwOnShadowProps = false) => {
+    const prop = getPropertyMetadata(metadata2, fieldName);
+    if (prop.persist === false && throwOnShadowProps) {
+      createAdapterError(
+        `Cannot serialize "${fieldName}" into path, because it cannot be persisted in "${metadata2.tableName}" table.`
+      );
+    }
+    if (prop.kind === ReferenceKind.SCALAR) {
+      return [prop.name];
+    }
+    if (prop.kind === ReferenceKind.MANY_TO_ONE) {
+      if (prop.referencedPKs.length > 1) {
+        createAdapterError(
+          `The "${fieldName}" field references to a table "${prop.name}" with complex primary key, which is not supported`
+        );
+      }
+      return [prop.name, naming.referenceColumnName()];
+    }
+    createAdapterError(
+      `Cannot normalize "${fieldName}" field name into path for "${metadata2.className} entity."`
+    );
+  };
+  const normalizeInput = (metadata2, input) => {
+    const fields = {};
+    Object.entries(input).forEach(([key, value]) => {
+      if (typeof value === "object" && value["$in"]) {
+        dset(fields, key, value["$in"]);
+      } else {
+        const path = getFieldPath(metadata2, key);
+        dset(fields, path, value);
+      }
+    });
+    return fields;
+  };
+  const normalizeOutput = (metadata2, output, select) => {
+    output = serialize(output);
+    const result = {};
+    Object.entries(output).map(([key, value]) => ({
+      path: getReferencedPropertyName(
+        metadata2,
+        getPropertyMetadata(metadata2, key)
+      ),
+      value
+    })).filter(({ path }) => select ? select.includes(path) : true).forEach(({ path, value }) => dset(result, path, value));
+    return result;
+  };
+  function createWhereClause(path, value, op, target = {}) {
+    dset(target, op == null || op === "eq" ? path : path.concat(op), value);
+    return target;
+  }
+  function createWhereInClause(fieldName, path, value, target) {
+    if (!Array.isArray(value)) {
+      createAdapterError(
+        `The value for the field "${fieldName}" must be an array when using the $in operator.`
+      );
+    }
+    return createWhereClause(path, value, "$in", target);
+  }
+  const normalizeWhereClauses = (metadata2, where) => {
+    if (!where) {
+      return {};
+    }
+    if (where.length === 1) {
+      const [w] = where;
+      if (!w) {
+        return {};
+      }
+      const path = getFieldPath(metadata2, w.field, true);
+      switch (w.operator) {
+        case "in":
+          return createWhereInClause(w.field, path, w.value);
+        case "contains":
+          return createWhereClause(path, `%${w.value}%`, "$like");
+        case "starts_with":
+          return createWhereClause(path, `${w.value}%`, "$like");
+        case "ends_with":
+          return createWhereClause(path, `%${w.value}`, "$like");
+        // The next 5 case statemets are _expected_ to fall through so we can simplify and reuse the same logic for these operators
+        case "gt":
+        case "gte":
+        case "lt":
+        case "lte":
+        case "ne":
+          return createWhereClause(path, w.value, `$${w.operator}`);
+        default:
+          return createWhereClause(path, w.value);
+      }
+    }
+    const result = {};
+    where.filter(({ connector }) => !connector || connector === "AND").forEach(({ field, operator, value }, index) => {
+      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)
+      );
+      return createWhereClause(path, value, "eq", result);
+    });
+    return result;
+  };
+  return {
+    getEntityMetadata,
+    normalizeEntityName,
+    getFieldPath,
+    normalizeInput,
+    normalizeOutput,
+    normalizeWhereClauses
+  };
+}
+
+// src/adapter.ts
+function mikroOrmAdapter(orm) {
+  const {
+    getEntityMetadata,
+    getFieldPath,
+    normalizeInput,
+    normalizeOutput,
+    normalizeWhereClauses
+  } = createAdapterUtils(orm);
+  const adapter = (options = {}) => ({
+    id: "mikro-orm",
+    async create({ model, data, select }) {
+      const metadata = getEntityMetadata(model);
+      const input = normalizeInput(metadata, data);
+      if (options.advanced?.generateId !== false) {
+        input.id = typeof options.advanced?.generateId === "function" ? options.advanced.generateId({ model }) : generateId();
+      }
+      const entity = orm.em.create(metadata.class, input);
+      await orm.em.persistAndFlush(entity);
+      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));
+      await orm.em.flush();
+      return normalizeOutput(metadata, entity);
+    },
+    async updateMany({ model, where, update }) {
+      const metadata = getEntityMetadata(model);
+      const affected = await orm.em.nativeUpdate(
+        metadata.class,
+        normalizeWhereClauses(metadata, where),
+        normalizeInput(metadata, update)
+      );
+      orm.em.clear();
+      return affected;
+    },
+    async delete({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      const entity = await orm.em.findOne(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      if (entity) {
+        await orm.em.removeAndFlush(entity);
+      }
+    },
+    async deleteMany({ model, where }) {
+      const metadata = getEntityMetadata(model);
+      const affected = await orm.em.nativeDelete(
+        metadata.class,
+        normalizeWhereClauses(metadata, where)
+      );
+      orm.em.clear();
+      return affected;
+    }
+  });
+  return adapter;
+}
+export {
+  mikroOrmAdapter
+};

package/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024-present Nick K.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,86 @@
+{
+  "private": false,
+  "type": "module",
+  "name": "@forklaunch/better-auth-mikro-orm-fork",
+  "version": "0.3.0",
+  "description": "Mikro ORM Adapter for Better Auth",
+  "keywords": [
+    "auth",
+    "better-auth",
+    "db",
+    "database",
+    "adapter",
+    "better-auth-adapter",
+    "mikro-orm"
+  ],
+  "author": "Nick K.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/octet-stream/better-auth-mikro-orm.git"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "types": "./lib/adapter.d.cts",
+  "main": "./lib/adapter.cjs",
+  "exports": {
+    ".": {
+      "node": {
+        "types": "./lib/adapter.d.cts",
+        "module-sync": "./lib/adapter.js",
+        "default": "./lib/adapter.cjs"
+      },
+      "import": {
+        "types": "./lib/adapter.d.ts",
+        "default": "./lib/adapter.js"
+      },
+      "default": {
+        "types": "./lib/adapter.d.cts",
+        "default": "./lib/adapter.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "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",
+    "better-auth": "1.2.7",
+    "del-cli": "6.0.0",
+    "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"
+  },
+  "dependencies": {
+    "dset": "3.1.4"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "^6.0.0",
+    "better-auth": "^1.0.0"
+  },
+  "scripts": {
+    "build": "del-cli lib && tsup-node",
+    "test": "vitest run",
+    "test.watch": "vitest",
+    "test.ui": "vitest --ui",
+    "coverage": "vitest run --coverage",
+    "release": "pnpm build && changeset publish"
+  }
+}

package/readme.md

@@ -0,0 +1,53 @@
+# better-auth-mikro-orm
+
+[Mikro ORM](https://mikro-orm.io/) adapter for [Better Auth](https://www.better-auth.com/)
+
+## Installation
+
+pnpm:
+
+```sh
+pnpm add better-auth-mikro-orm
+```
+
+npm:
+
+```sh
+npm i better-auth-mikro-orm
+```
+
+## Usage
+
+1. First you'll need to set up Mikro ORM and define the [core schema](https://www.better-auth.com/docs/concepts/database#core-schema) for Better Auth.
+If you use any plugin - don't forget to check if they have any additional database schema definitions, then define entities you'll need for each plugin.
+2. When you finished with the schema definition you can simply pass the result of `mikroOrmAdapter` call to the `database` option like this:
+
+```ts
+import {mikroOrmAdapter} from "better-auth-mikro-orm"
+import {betterAuth} from "better-auth"
+
+import {orm} from "./orm.js" // Your Mikro ORM instance
+
+export const auth = betterAuth({
+  database: mikroOrmAdapter(orm),
+
+  // Don't forget to disable ID generator if it already managed by Mikro ORM:
+  advanced: {
+    generateId: false
+  }
+})
+```
+
+## API
+
+### `mikroOrmAdapter(orm: MikroORM): AdapterInstance`
+
+Creates Mikro ORM adapter instance. Note that this adapter **does not** manage database schema for you, so you can't use it with [`@better-auth/cli`](https://www.better-auth.com/docs/concepts/cli).
+This means you'll have to manage database schema on your own.
+Please refer to Better Auth and Mikro ORM documentation on the details.
+
+Returns `AdapterInstance` function for Better Auth `database` option.
+
+This function expects a single argument:
+
+* `orm` - An instance of `MikroORM` returned from `MikroORM.init` or `MikroORM.initSync` methods.