better-auth 1.2.6-beta.7 → 1.2.6

package/dist/adapters/drizzle-adapter/index.cjs

@@ -1,9 +1,12 @@
 'use strict';
 
 const drizzleOrm = require('drizzle-orm');
-require('../../shared/better-auth.C5H9XEzZ.cjs');
-require('../../shared/better-auth.DiSjtgs9.cjs');
-const id = require('../../shared/better-auth.Bg6iw3ig.cjs');
+const index$1 = require('../../shared/better-auth.ANpbi45u.cjs');
+const index = require('../../shared/better-auth.BGJuANtq.cjs');
+require('../../shared/better-auth.D3mtHEZg.cjs');
+require('../../shared/better-auth.BEphVDyL.cjs');
+require('../../shared/better-auth.Bg6iw3ig.cjs');
+require('@better-auth/utils/random');
 require('zod');
 require('better-call');
 require('@better-auth/utils/hash');
@@ -18,148 +21,31 @@ require('@better-auth/utils/hex');
 require('@noble/hashes/utils');
 require('../../shared/better-auth.CYeOI8C-.cjs');
 require('../../shared/better-auth.GpOOav9x.cjs');
-const getTables = require('../../shared/better-auth.BEphVDyL.cjs');
-const index = require('../../shared/better-auth.ANpbi45u.cjs');
-require('kysely');
-const utils = require('../../shared/better-auth.CUdxApHl.cjs');
-require('@better-auth/utils/random');
 
-const createTransform = (db, config, options) => {
-  const schema = getTables.getAuthTables(options);
-  function getField(model, field) {
-    if (field === "id") {
-      return field;
-    }
-    const f = schema[model].fields[field];
-    return f.fieldName || field;
-  }
-  function getSchema(modelName) {
-    const schema2 = config.schema || db._.fullSchema;
-    if (!schema2) {
-      throw new index.BetterAuthError(
-        "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
-      );
-    }
-    const model = getModelName(modelName);
-    const schemaModel = schema2[model];
-    if (!schemaModel) {
-      throw new index.BetterAuthError(
-        `[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`
-      );
-    }
-    return schemaModel;
-  }
-  const getModelName = (model) => {
-    return schema[model].modelName !== model ? schema[model].modelName : config.usePlural ? `${model}s` : model;
-  };
-  function convertWhereClause(where, model) {
-    const schemaModel = getSchema(model);
-    if (!where) return [];
-    if (where.length === 1) {
-      const w = where[0];
-      if (!w) {
-        return [];
-      }
-      const field = getField(model, w.field);
-      if (!schemaModel[field]) {
-        throw new index.BetterAuthError(
-          `The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`
+const drizzleAdapter = (db, config) => index.createAdapter({
+  config: {
+    adapterId: "drizzle",
+    adapterName: "Drizzle Adapter",
+    usePlural: config.usePlural ?? false,
+    debugLogs: config.debugLogs ?? false
+  },
+  adapter: ({ getFieldName, debugLog }) => {
+    function getSchema(model) {
+      const schema = config.schema || db._.fullSchema;
+      if (!schema) {
+        throw new index$1.BetterAuthError(
+          "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
         );
       }
-      if (w.operator === "in") {
-        if (!Array.isArray(w.value)) {
-          throw new index.BetterAuthError(
-            `The value for the field "${w.field}" must be an array when using the "in" operator.`
-          );
-        }
-        return [drizzleOrm.inArray(schemaModel[field], w.value)];
-      }
-      if (w.operator === "contains") {
-        return [drizzleOrm.like(schemaModel[field], `%${w.value}%`)];
-      }
-      if (w.operator === "starts_with") {
-        return [drizzleOrm.like(schemaModel[field], `${w.value}%`)];
-      }
-      if (w.operator === "ends_with") {
-        return [drizzleOrm.like(schemaModel[field], `%${w.value}`)];
-      }
-      if (w.operator === "lt") {
-        return [drizzleOrm.lt(schemaModel[field], w.value)];
-      }
-      if (w.operator === "lte") {
-        return [drizzleOrm.lte(schemaModel[field], w.value)];
-      }
-      return [drizzleOrm.eq(schemaModel[field], w.value)];
-    }
-    const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
-    const orGroup = where.filter((w) => w.connector === "OR");
-    const andClause = drizzleOrm.and(
-      ...andGroup.map((w) => {
-        const field = getField(model, w.field);
-        if (w.operator === "in") {
-          if (!Array.isArray(w.value)) {
-            throw new index.BetterAuthError(
-              `The value for the field "${w.field}" must be an array when using the "in" operator.`
-            );
-          }
-          return drizzleOrm.inArray(schemaModel[field], w.value);
-        }
-        return drizzleOrm.eq(schemaModel[field], w.value);
-      })
-    );
-    const orClause = drizzleOrm.or(
-      ...orGroup.map((w) => {
-        const field = getField(model, w.field);
-        return drizzleOrm.eq(schemaModel[field], w.value);
-      })
-    );
-    const clause = [];
-    if (andGroup.length) clause.push(andClause);
-    if (orGroup.length) clause.push(orClause);
-    return clause;
-  }
-  const useDatabaseGeneratedId = options?.advanced?.generateId === false;
-  return {
-    getSchema,
-    transformInput(data, model, action) {
-      const transformedData = useDatabaseGeneratedId || action === "update" ? {} : {
-        id: options.advanced?.generateId ? options.advanced.generateId({
-          model
-        }) : data.id || id.generateId()
-      };
-      const fields = schema[model].fields;
-      for (const field in fields) {
-        const value = data[field];
-        if (value === void 0 && !fields[field].defaultValue) {
-          continue;
-        }
-        transformedData[fields[field].fieldName || field] = utils.withApplyDefault(
-          value,
-          fields[field],
-          action
+      const schemaModel = schema[model];
+      if (!schemaModel) {
+        throw new index$1.BetterAuthError(
+          `[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`
         );
       }
-      return transformedData;
-    },
-    transformOutput(data, model, select = []) {
-      if (!data) return null;
-      const transformedData = data.id || data._id ? select.length === 0 || select.includes("id") ? {
-        id: data.id
-      } : {} : {};
-      const tableSchema = schema[model].fields;
-      for (const key in tableSchema) {
-        if (select.length && !select.includes(key)) {
-          continue;
-        }
-        const field = tableSchema[key];
-        if (field) {
-          transformedData[key] = data[field.fieldName || key];
-        }
-      }
-      return transformedData;
-    },
-    convertWhereClause,
-    withReturning: async (model, builder, data, where) => {
+      return schemaModel;
+    }
+    const withReturning = async (model, builder, data, where) => {
       if (config.provider !== "mysql") {
         const c = await builder.returning();
         return c[0];
@@ -171,121 +57,171 @@ const createTransform = (db, config, options) => {
         const clause = convertWhereClause(where, model);
         const res = await db.select().from(schemaModel).where(...clause);
         return res[0];
-      } else if (builderVal) {
-        const tId = builderVal[0]?.id.value;
-        const res = await db.select().from(schemaModel).where(drizzleOrm.eq(schemaModel.id, tId));
+      } else if (builderVal && builderVal[0]?.id?.value) {
+        let tId = builderVal[0]?.id?.value;
+        if (!tId) {
+          const lastInsertId = await db.select({ id: drizzleOrm.sql`LAST_INSERT_ID()` }).from(schemaModel).orderBy(drizzleOrm.desc(schemaModel.id)).limit(1);
+          tId = lastInsertId[0].id;
+        }
+        const res = await db.select().from(schemaModel).where(drizzleOrm.eq(schemaModel.id, tId)).limit(1).execute();
         return res[0];
       } else if (data.id) {
-        const res = await db.select().from(schemaModel).where(drizzleOrm.eq(schemaModel.id, data.id));
+        const res = await db.select().from(schemaModel).where(drizzleOrm.eq(schemaModel.id, data.id)).limit(1).execute();
+        return res[0];
+      } else {
+        if (!("id" in schemaModel)) {
+          throw new index$1.BetterAuthError(
+            `The model "${model}" does not have an "id" field. Please use the "id" field as your primary key.`
+          );
+        }
+        const res = await db.select().from(schemaModel).orderBy(drizzleOrm.desc(schemaModel.id)).limit(1).execute();
         return res[0];
       }
-    },
-    getField,
-    getModelName
-  };
-};
-function checkMissingFields(schema, model, values) {
-  if (!schema) {
-    throw new index.BetterAuthError(
-      "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
-    );
-  }
-  for (const key in values) {
-    if (!schema[key]) {
-      throw new index.BetterAuthError(
-        `The field "${key}" does not exist in the "${model}" schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli generate".`
-      );
-    }
-  }
-}
-const drizzleAdapter = (db, config) => (options) => {
-  const {
-    transformInput,
-    transformOutput,
-    convertWhereClause,
-    getSchema,
-    withReturning,
-    getField,
-    getModelName
-  } = createTransform(db, config, options);
-  return {
-    id: "drizzle",
-    async create(data) {
-      const { model, data: values } = data;
-      const transformed = transformInput(values, model, "create");
-      const schemaModel = getSchema(model);
-      checkMissingFields(schemaModel, getModelName(model), transformed);
-      const builder = db.insert(schemaModel).values(transformed);
-      const returned = await withReturning(model, builder, transformed);
-      return transformOutput(returned, model);
-    },
-    async findOne(data) {
-      const { model, where, select } = data;
+    };
+    function convertWhereClause(where, model) {
       const schemaModel = getSchema(model);
-      const clause = convertWhereClause(where, model);
-      const res = await db.select().from(schemaModel).where(...clause);
-      if (!res.length) return null;
-      return transformOutput(res[0], model, select);
-    },
-    async findMany(data) {
-      const { model, where, sortBy, limit, offset } = data;
-      const schemaModel = getSchema(model);
-      const clause = where ? convertWhereClause(where, model) : [];
-      const sortFn = sortBy?.direction === "desc" ? drizzleOrm.desc : drizzleOrm.asc;
-      const builder = db.select().from(schemaModel).limit(limit || 100).offset(offset || 0);
-      if (sortBy?.field) {
-        builder.orderBy(sortFn(schemaModel[getField(model, sortBy?.field)]));
+      if (!where) return [];
+      if (where.length === 1) {
+        const w = where[0];
+        if (!w) {
+          return [];
+        }
+        const field = getFieldName({ model, field: w.field });
+        if (!schemaModel[field]) {
+          throw new index$1.BetterAuthError(
+            `The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`
+          );
+        }
+        if (w.operator === "in") {
+          if (!Array.isArray(w.value)) {
+            throw new index$1.BetterAuthError(
+              `The value for the field "${w.field}" must be an array when using the "in" operator.`
+            );
+          }
+          return [drizzleOrm.inArray(schemaModel[field], w.value)];
+        }
+        if (w.operator === "contains") {
+          return [drizzleOrm.like(schemaModel[field], `%${w.value}%`)];
+        }
+        if (w.operator === "starts_with") {
+          return [drizzleOrm.like(schemaModel[field], `${w.value}%`)];
+        }
+        if (w.operator === "ends_with") {
+          return [drizzleOrm.like(schemaModel[field], `%${w.value}`)];
+        }
+        if (w.operator === "lt") {
+          return [drizzleOrm.lt(schemaModel[field], w.value)];
+        }
+        if (w.operator === "lte") {
+          return [drizzleOrm.lte(schemaModel[field], w.value)];
+        }
+        return [drizzleOrm.eq(schemaModel[field], w.value)];
       }
-      const res = await builder.where(...clause);
-      return res.map((r) => transformOutput(r, model));
-    },
-    async count(data) {
-      const { model, where } = data;
-      const schemaModel = getSchema(model);
-      const clause = where ? convertWhereClause(where, model) : [];
-      const res = await db.select({ count: drizzleOrm.count() }).from(schemaModel).where(...clause);
-      return res.count;
-    },
-    async update(data) {
-      const { model, where, update: values } = data;
-      const schemaModel = getSchema(model);
-      const clause = convertWhereClause(where, model);
-      const transformed = transformInput(values, model, "update");
-      const builder = db.update(schemaModel).set(transformed).where(...clause);
-      const returned = await withReturning(
-        model,
-        builder,
-        transformed,
-        where
+      const andGroup = where.filter(
+        (w) => w.connector === "AND" || !w.connector
       );
-      return transformOutput(returned, model);
-    },
-    async updateMany(data) {
-      const { model, where, update: values } = data;
-      const schemaModel = getSchema(model);
-      const clause = convertWhereClause(where, model);
-      const transformed = transformInput(values, model, "update");
-      const builder = db.update(schemaModel).set(transformed).where(...clause);
-      const res = await builder;
-      return res ? res.changes : 0;
-    },
-    async delete(data) {
-      const { model, where } = data;
-      const schemaModel = getSchema(model);
-      const clause = convertWhereClause(where, model);
-      const builder = db.delete(schemaModel).where(...clause);
-      await builder;
-    },
-    async deleteMany(data) {
-      const { model, where } = data;
-      const schemaModel = getSchema(model);
-      const clause = convertWhereClause(where, model);
-      const builder = db.delete(schemaModel).where(...clause);
-      const res = await builder;
-      return res ? res.length : 0;
-    },
-    options: config
-  };
-};
+      const orGroup = where.filter((w) => w.connector === "OR");
+      const andClause = drizzleOrm.and(
+        ...andGroup.map((w) => {
+          const field = getFieldName({ model, field: w.field });
+          if (w.operator === "in") {
+            if (!Array.isArray(w.value)) {
+              throw new index$1.BetterAuthError(
+                `The value for the field "${w.field}" must be an array when using the "in" operator.`
+              );
+            }
+            return drizzleOrm.inArray(schemaModel[field], w.value);
+          }
+          return drizzleOrm.eq(schemaModel[field], w.value);
+        })
+      );
+      const orClause = drizzleOrm.or(
+        ...orGroup.map((w) => {
+          const field = getFieldName({ model, field: w.field });
+          return drizzleOrm.eq(schemaModel[field], w.value);
+        })
+      );
+      const clause = [];
+      if (andGroup.length) clause.push(andClause);
+      if (orGroup.length) clause.push(orClause);
+      return clause;
+    }
+    function checkMissingFields(schema, model, values) {
+      if (!schema) {
+        throw new index$1.BetterAuthError(
+          "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
+        );
+      }
+      for (const key in values) {
+        if (!schema[key]) {
+          throw new index$1.BetterAuthError(
+            `The field "${key}" does not exist in the "${model}" schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli generate".`
+          );
+        }
+      }
+    }
+    return {
+      async create({ model, data: values }) {
+        const schemaModel = getSchema(model);
+        checkMissingFields(schemaModel, model, values);
+        const builder = db.insert(schemaModel).values(values);
+        const returned = await withReturning(model, builder, values);
+        return returned;
+      },
+      async findOne({ model, where }) {
+        const schemaModel = getSchema(model);
+        const clause = convertWhereClause(where, model);
+        const res = await db.select().from(schemaModel).where(...clause);
+        if (!res.length) return null;
+        return res[0];
+      },
+      async findMany({ model, where, sortBy, limit, offset }) {
+        const schemaModel = getSchema(model);
+        const clause = where ? convertWhereClause(where, model) : [];
+        const sortFn = sortBy?.direction === "desc" ? drizzleOrm.desc : drizzleOrm.asc;
+        const builder = db.select().from(schemaModel).limit(limit || 100).offset(offset || 0);
+        if (sortBy?.field) {
+          builder.orderBy(
+            sortFn(
+              schemaModel[getFieldName({ model, field: sortBy?.field })]
+            )
+          );
+        }
+        return await builder.where(...clause);
+      },
+      async count({ model, where }) {
+        const schemaModel = getSchema(model);
+        const clause = where ? convertWhereClause(where, model) : [];
+        const res = await db.select({ count: drizzleOrm.count() }).from(schemaModel).where(...clause);
+        return res.count;
+      },
+      async update({ model, where, update: values }) {
+        const schemaModel = getSchema(model);
+        const clause = convertWhereClause(where, model);
+        const builder = db.update(schemaModel).set(values).where(...clause);
+        return await withReturning(model, builder, values, where);
+      },
+      async updateMany({ model, where, update: values }) {
+        const schemaModel = getSchema(model);
+        const clause = convertWhereClause(where, model);
+        const builder = db.update(schemaModel).set(values).where(...clause);
+        return await builder;
+      },
+      async delete({ model, where }) {
+        const schemaModel = getSchema(model);
+        const clause = convertWhereClause(where, model);
+        const builder = db.delete(schemaModel).where(...clause);
+        return await builder;
+      },
+      async deleteMany({ model, where }) {
+        const schemaModel = getSchema(model);
+        const clause = convertWhereClause(where, model);
+        const builder = db.delete(schemaModel).where(...clause);
+        return await builder;
+      },
+      options: config
+    };
+  }
+});
 
 exports.drizzleAdapter = drizzleAdapter;

package/dist/adapters/drizzle-adapter/index.d.cts

@@ -1,7 +1,8 @@
-import { f as BetterAuthOptions, W as Where } from '../../shared/better-auth.BiQsvaIP.cjs';
-import '../../shared/better-auth.Bi8FQwDD.cjs';
+import { f as BetterAuthOptions, g as Adapter } from '../../shared/better-auth.BcU1Kjyq.cjs';
+import { A as AdapterDebugLogs } from '../../shared/better-auth.eVy4DZvP.cjs';
+import '../../shared/better-auth.CYegVoq1.cjs';
 import 'zod';
-import '../../shared/better-auth.B2Fw1vhH.cjs';
+import '../../shared/better-auth.DTiSPWEk.cjs';
 import 'jose';
 import 'kysely';
 import 'better-call';
@@ -25,52 +26,13 @@ interface DrizzleAdapterConfig {
      * has an object with a key "users" instead of "user"
      */
     usePlural?: boolean;
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: AdapterDebugLogs;
 }
-declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => {
-    id: string;
-    create<T extends Record<string, any>, R = T>(data: {
-        model: string;
-        data: T;
-        select?: string[];
-    }): Promise<any>;
-    findOne<T>(data: {
-        model: string;
-        where: Where[];
-        select?: string[];
-    }): Promise<any>;
-    findMany<T>(data: {
-        model: string;
-        where?: Where[];
-        limit?: number;
-        sortBy?: {
-            field: string;
-            direction: "asc" | "desc";
-        };
-        offset?: number;
-    }): Promise<any[]>;
-    count(data: {
-        model: string;
-        where?: Where[];
-    }): Promise<any>;
-    update<T>(data: {
-        model: string;
-        where: Where[];
-        update: Record<string, any>;
-    }): Promise<any>;
-    updateMany(data: {
-        model: string;
-        where: Where[];
-        update: Record<string, any>;
-    }): Promise<any>;
-    delete<T>(data: {
-        model: string;
-        where: Where[];
-    }): Promise<void>;
-    deleteMany(data: {
-        model: string;
-        where: Where[];
-    }): Promise<any>;
-    options: DrizzleAdapterConfig;
-};
+declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => Adapter;
 
 export { type DB, type DrizzleAdapterConfig, drizzleAdapter };

package/dist/adapters/drizzle-adapter/index.d.mts

@@ -1,7 +1,8 @@
-import { f as BetterAuthOptions, W as Where } from '../../shared/better-auth.D-oLmHIj.mjs';
-import '../../shared/better-auth.Bi8FQwDD.mjs';
+import { f as BetterAuthOptions, g as Adapter } from '../../shared/better-auth.DQ7OSJbI.mjs';
+import { A as AdapterDebugLogs } from '../../shared/better-auth.SPmq4a4z.mjs';
+import '../../shared/better-auth.CYegVoq1.mjs';
 import 'zod';
-import '../../shared/better-auth.bKwabe3I.mjs';
+import '../../shared/better-auth.B88xucNq.mjs';
 import 'jose';
 import 'kysely';
 import 'better-call';
@@ -25,52 +26,13 @@ interface DrizzleAdapterConfig {
      * has an object with a key "users" instead of "user"
      */
     usePlural?: boolean;
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: AdapterDebugLogs;
 }
-declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => {
-    id: string;
-    create<T extends Record<string, any>, R = T>(data: {
-        model: string;
-        data: T;
-        select?: string[];
-    }): Promise<any>;
-    findOne<T>(data: {
-        model: string;
-        where: Where[];
-        select?: string[];
-    }): Promise<any>;
-    findMany<T>(data: {
-        model: string;
-        where?: Where[];
-        limit?: number;
-        sortBy?: {
-            field: string;
-            direction: "asc" | "desc";
-        };
-        offset?: number;
-    }): Promise<any[]>;
-    count(data: {
-        model: string;
-        where?: Where[];
-    }): Promise<any>;
-    update<T>(data: {
-        model: string;
-        where: Where[];
-        update: Record<string, any>;
-    }): Promise<any>;
-    updateMany(data: {
-        model: string;
-        where: Where[];
-        update: Record<string, any>;
-    }): Promise<any>;
-    delete<T>(data: {
-        model: string;
-        where: Where[];
-    }): Promise<void>;
-    deleteMany(data: {
-        model: string;
-        where: Where[];
-    }): Promise<any>;
-    options: DrizzleAdapterConfig;
-};
+declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => Adapter;
 
 export { type DB, type DrizzleAdapterConfig, drizzleAdapter };

package/dist/adapters/drizzle-adapter/index.d.ts

@@ -1,7 +1,8 @@
-import { f as BetterAuthOptions, W as Where } from '../../shared/better-auth.DU2QNVc_.js';
-import '../../shared/better-auth.Bi8FQwDD.js';
+import { f as BetterAuthOptions, g as Adapter } from '../../shared/better-auth.CA2hFK4N.js';
+import { A as AdapterDebugLogs } from '../../shared/better-auth.cp2rC2iM.js';
+import '../../shared/better-auth.CYegVoq1.js';
 import 'zod';
-import '../../shared/better-auth.BANAxdkL.js';
+import '../../shared/better-auth.DNTAFSt1.js';
 import 'jose';
 import 'kysely';
 import 'better-call';
@@ -25,52 +26,13 @@ interface DrizzleAdapterConfig {
      * has an object with a key "users" instead of "user"
      */
     usePlural?: boolean;
+    /**
+     * Enable debug logs for the adapter
+     *
+     * @default false
+     */
+    debugLogs?: AdapterDebugLogs;
 }
-declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => {
-    id: string;
-    create<T extends Record<string, any>, R = T>(data: {
-        model: string;
-        data: T;
-        select?: string[];
-    }): Promise<any>;
-    findOne<T>(data: {
-        model: string;
-        where: Where[];
-        select?: string[];
-    }): Promise<any>;
-    findMany<T>(data: {
-        model: string;
-        where?: Where[];
-        limit?: number;
-        sortBy?: {
-            field: string;
-            direction: "asc" | "desc";
-        };
-        offset?: number;
-    }): Promise<any[]>;
-    count(data: {
-        model: string;
-        where?: Where[];
-    }): Promise<any>;
-    update<T>(data: {
-        model: string;
-        where: Where[];
-        update: Record<string, any>;
-    }): Promise<any>;
-    updateMany(data: {
-        model: string;
-        where: Where[];
-        update: Record<string, any>;
-    }): Promise<any>;
-    delete<T>(data: {
-        model: string;
-        where: Where[];
-    }): Promise<void>;
-    deleteMany(data: {
-        model: string;
-        where: Where[];
-    }): Promise<any>;
-    options: DrizzleAdapterConfig;
-};
+declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => Adapter;
 
 export { type DB, type DrizzleAdapterConfig, drizzleAdapter };