better-auth 0.2.3-beta.8 → 0.2.4

package/dist/adapters.js

@@ -1,22 +1,1163 @@
-import{existsSync as K}from"fs";import E from"path";var C=e=>{let o=e.plugins?.reduce((c,l)=>{let d=l.schema;if(!d)return c;for(let[u,p]of Object.entries(d))c[u]={fields:{...c[u]?.fields,...p.fields},tableName:u};return c},{}),a=e.rateLimit?.storage==="database",r={rateLimit:{tableName:e.rateLimit?.tableName||"rateLimit",fields:{key:{type:"string"},count:{type:"number"},lastRequest:{type:"number"}}}},{user:s,session:t,account:n,...i}=o||{};return{user:{tableName:e.user?.modelName||"user",fields:{name:{type:"string",required:!0},email:{type:"string",unique:!0,required:!0},emailVerified:{type:"boolean",defaultValue:()=>!1,required:!0},image:{type:"string",required:!1},createdAt:{type:"date",defaultValue:()=>new Date,required:!0},updatedAt:{type:"date",defaultValue:()=>new Date,required:!0},...s?.fields},order:0},session:{tableName:e.session?.modelName||"session",fields:{expiresAt:{type:"date",required:!0},ipAddress:{type:"string",required:!1},userAgent:{type:"string",required:!1},userId:{type:"string",references:{model:"user",field:"id",onDelete:"cascade"},required:!0},...t?.fields},order:1},account:{tableName:e.account?.modelName||"account",fields:{accountId:{type:"string",required:!0},providerId:{type:"string",required:!0},userId:{type:"string",references:{model:"user",field:"id",onDelete:"cascade"},required:!0},accessToken:{type:"string",required:!1},refreshToken:{type:"string",required:!1},idToken:{type:"string",required:!1},expiresAt:{type:"date",required:!1},password:{type:"string",required:!1},...n?.fields},order:2},...i,...a?r:{}}};import W from"fs/promises";import{produceSchema as H}from"@mrleebo/prisma-ast";var w=class extends Error{constructor(o,a,r){super(o),this.name="BetterAuthError",this.message=o,this.cause=a}};import{TimeSpan as he}from"oslo";import{alphabet as ke,generateRandomString as Ce}from"oslo/crypto";import{createConsola as V}from"consola";var k=V({formatOptions:{date:!1,colors:!0,compact:!0},defaults:{tag:"Better Auth"}}),G=e=>({log:(...o)=>{!e?.disabled&&k.log("",...o)},error:(...o)=>{!e?.disabled&&k.error("",...o)},warn:(...o)=>{!e?.disabled&&k.warn("",...o)},info:(...o)=>{!e?.disabled&&k.info("",...o)},debug:(...o)=>{!e?.disabled&&k.debug("",...o)},box:(...o)=>{!e?.disabled&&k.box("",...o)},success:(...o)=>{!e?.disabled&&k.success("",...o)},break:(...o)=>{!e?.disabled&&console.log(`
-`)}}),N=G();function D(e){return e.charAt(0).toUpperCase()+e.slice(1)}import{generateState as De}from"oslo/oauth2";import{z as Pe}from"zod";function O(e){if(!e)return{};if(e.length===1){let t=e[0];return t?{[t.field]:t.value}:void 0}let o=e.filter(t=>t.connector==="AND"||!t.connector),a=e.filter(t=>t.connector==="OR"),r=o.map(t=>({[t.field]:t.operator==="eq"||!t.operator?t.value:{[t.operator]:t.value}})),s=a.map(t=>({[t.field]:{[t.operator||"eq"]:t.value}}));return{AND:r.length?r:void 0,OR:s.length?s:void 0}}var nt=({db:e,provider:o})=>{let a=e;return{id:"prisma",async create(r){let{model:s,data:t,select:n}=r;return await a[s].create({data:t,...n?.length?{select:n.reduce((i,c)=>({...i,[c]:!0}),{})}:{}})},async findOne(r){let{model:s,where:t,select:n}=r,i=O(t);return await a[s].findFirst({where:i,...n?.length?{select:n.reduce((c,l)=>({...c,[l]:!0}),{})}:{}})},async findMany(r){let{model:s,where:t}=r,n=O(t);return await a[s].findMany({where:n})},async update(r){let{model:s,where:t,update:n}=r,i=O(t);return await a[s].update({where:i,data:n})},async delete(r){let{model:s,where:t}=r,n=O(t);return await a[s].delete({where:n})},async createSchema(r,s){let t=C(r),n=s||"./prisma/schema.prisma",i=K(E.join(process.cwd(),n)),c="";return i?c=await W.readFile(E.join(process.cwd(),n),"utf-8"):c=X(o),{code:H(c,d=>{for(let p in t){let b=function(y,h){if(y==="string")return h?"String?":"String";if(y==="number")return h?"Int?":"Int";if(y==="boolean")return h?"Boolean?":"Boolean";if(y==="date")return h?"DateTime?":"DateTime"};var u=b;let g=t[p].fields,m=t[p].tableName,f=d.findByType("model",{name:m});!f&&d.model(m).field("id","String").attribute("id");for(let y in g){let h=g[y];if(f){let A=d.findByType("field",{name:y,within:f.properties});if(console.log(y,"exists"),A)continue}d.model(m).field(y,b(h.type,!h.required)),h.unique&&d.model(m).blockAttribute(`unique([${y}])`),h.references&&d.model(m).field(D(h.references.model),h.references.model).attribute(`relation(fields: [${y}], references: [${h.references.field}], onDelete: Cascade)`)}}}),fileName:n}}}},X=e=>`generator client {
+// src/adapters/prisma-adapter/index.ts
+import { existsSync } from "fs";
+import path from "path";
+
+// src/db/get-tables.ts
+var getAuthTables = (options) => {
+  const pluginSchema = options.plugins?.reduce(
+    (acc, plugin) => {
+      const schema = plugin.schema;
+      if (!schema) return acc;
+      for (const [key, value] of Object.entries(schema)) {
+        acc[key] = {
+          fields: {
+            ...acc[key]?.fields,
+            ...value.fields
+          },
+          tableName: key
+        };
+      }
+      return acc;
+    },
+    {}
+  );
+  const shouldAddRateLimitTable = options.rateLimit?.storage === "database";
+  const rateLimitTable = {
+    rateLimit: {
+      tableName: options.rateLimit?.tableName || "rateLimit",
+      fields: {
+        key: {
+          type: "string"
+        },
+        count: {
+          type: "number"
+        },
+        lastRequest: {
+          type: "number"
+        }
+      }
+    }
+  };
+  const { user, session, account, ...pluginTables } = pluginSchema || {};
+  return {
+    user: {
+      tableName: options.user?.modelName || "user",
+      fields: {
+        name: {
+          type: "string",
+          required: true
+        },
+        email: {
+          type: "string",
+          unique: true,
+          required: true
+        },
+        emailVerified: {
+          type: "boolean",
+          defaultValue: () => false,
+          required: true
+        },
+        image: {
+          type: "string",
+          required: false
+        },
+        createdAt: {
+          type: "date",
+          defaultValue: () => /* @__PURE__ */ new Date(),
+          required: true
+        },
+        updatedAt: {
+          type: "date",
+          defaultValue: () => /* @__PURE__ */ new Date(),
+          required: true
+        },
+        ...user?.fields
+      },
+      order: 0
+    },
+    session: {
+      tableName: options.session?.modelName || "session",
+      fields: {
+        expiresAt: {
+          type: "date",
+          required: true
+        },
+        ipAddress: {
+          type: "string",
+          required: false
+        },
+        userAgent: {
+          type: "string",
+          required: false
+        },
+        userId: {
+          type: "string",
+          references: {
+            model: "user",
+            field: "id",
+            onDelete: "cascade"
+          },
+          required: true
+        },
+        ...session?.fields
+      },
+      order: 1
+    },
+    account: {
+      tableName: options.account?.modelName || "account",
+      fields: {
+        accountId: {
+          type: "string",
+          required: true
+        },
+        providerId: {
+          type: "string",
+          required: true
+        },
+        userId: {
+          type: "string",
+          references: {
+            model: "user",
+            field: "id",
+            onDelete: "cascade"
+          },
+          required: true
+        },
+        accessToken: {
+          type: "string",
+          required: false
+        },
+        refreshToken: {
+          type: "string",
+          required: false
+        },
+        idToken: {
+          type: "string",
+          required: false
+        },
+        expiresAt: {
+          type: "date",
+          required: false
+        },
+        password: {
+          type: "string",
+          required: false
+        },
+        ...account?.fields
+      },
+      order: 2
+    },
+    ...pluginTables,
+    ...shouldAddRateLimitTable ? rateLimitTable : {}
+  };
+};
+
+// src/adapters/prisma-adapter/index.ts
+import fs from "fs/promises";
+import { produceSchema } from "@mrleebo/prisma-ast";
+
+// src/error/better-auth-error.ts
+var BetterAuthError = class extends Error {
+  constructor(message, cause, docsLink) {
+    super(message);
+    this.name = "BetterAuthError";
+    this.message = message;
+    this.cause = cause;
+    this.stack = "";
+  }
+};
+var MissingDependencyError = class extends BetterAuthError {
+  constructor(pkgName) {
+    super(
+      `The package "${pkgName}" is required. Make sure it is installed.`,
+      pkgName
+    );
+  }
+};
+
+// src/utils/cookies.ts
+import { TimeSpan } from "oslo";
+
+// src/utils/id.ts
+import { alphabet, generateRandomString } from "oslo/crypto";
+
+// src/utils/logger.ts
+import { createConsola } from "consola";
+var consola = createConsola({
+  formatOptions: {
+    date: false,
+    colors: true,
+    compact: true
+  },
+  defaults: {
+    tag: "Better Auth"
+  }
+});
+var createLogger = (options) => {
+  return {
+    log: (...args) => {
+      !options?.disabled && consola.log("", ...args);
+    },
+    error: (...args) => {
+      !options?.disabled && consola.error("", ...args);
+    },
+    warn: (...args) => {
+      !options?.disabled && consola.warn("", ...args);
+    },
+    info: (...args) => {
+      !options?.disabled && consola.info("", ...args);
+    },
+    debug: (...args) => {
+      !options?.disabled && consola.debug("", ...args);
+    },
+    box: (...args) => {
+      !options?.disabled && consola.box("", ...args);
+    },
+    success: (...args) => {
+      !options?.disabled && consola.success("", ...args);
+    },
+    break: (...args) => {
+      !options?.disabled && console.log("\n");
+    }
+  };
+};
+var logger = createLogger();
+
+// src/utils/misc.ts
+function capitalizeFirstLetter(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/utils/state.ts
+import { generateState as generateStateOAuth } from "oslo/oauth2";
+import { z } from "zod";
+
+// src/adapters/prisma-adapter/index.ts
+function whereConvertor(where) {
+  if (!where) return {};
+  if (where.length === 1) {
+    const w = where[0];
+    if (!w) {
+      return;
+    }
+    return {
+      [w.field]: w.value
+    };
+  }
+  const and2 = where.filter((w) => w.connector === "AND" || !w.connector);
+  const or2 = where.filter((w) => w.connector === "OR");
+  const andClause = and2.map((w) => {
+    return {
+      [w.field]: w.operator === "eq" || !w.operator ? w.value : {
+        [w.operator]: w.value
+      }
+    };
+  });
+  const orClause = or2.map((w) => {
+    return {
+      [w.field]: {
+        [w.operator || "eq"]: w.value
+      }
+    };
+  });
+  return {
+    AND: andClause.length ? andClause : void 0,
+    OR: orClause.length ? orClause : void 0
+  };
+}
+var prismaAdapter = (prisma, {
+  provider
+}) => {
+  const db = prisma;
+  return {
+    id: "prisma",
+    async create(data) {
+      const { model, data: val, select } = data;
+      return await db[model].create({
+        data: val,
+        ...select?.length ? {
+          select: select.reduce((prev, cur) => {
+            return {
+              ...prev,
+              [cur]: true
+            };
+          }, {})
+        } : {}
+      });
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const whereClause = whereConvertor(where);
+      return await db[model].findFirst({
+        where: whereClause,
+        ...select?.length ? {
+          select: select.reduce((prev, cur) => {
+            return {
+              ...prev,
+              [cur]: true
+            };
+          }, {})
+        } : {}
+      });
+    },
+    async findMany(data) {
+      const { model, where } = data;
+      const whereClause = whereConvertor(where);
+      return await db[model].findMany({ where: whereClause });
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      const whereClause = whereConvertor(where);
+      return await db[model].update({
+        where: whereClause,
+        data: update
+      });
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const whereClause = whereConvertor(where);
+      return await db[model].delete({ where: whereClause });
+    },
+    async createSchema(options, file) {
+      const tables = getAuthTables(options);
+      const filePath = file || "./prisma/schema.prisma";
+      const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
+      let schemaPrisma = "";
+      if (schemaPrismaExist) {
+        schemaPrisma = await fs.readFile(
+          path.join(process.cwd(), filePath),
+          "utf-8"
+        );
+      } else {
+        schemaPrisma = getNewPrisma(provider);
+      }
+      const schema = produceSchema(schemaPrisma, (builder) => {
+        for (const table in tables) {
+          let getType2 = function(type, isOptional) {
+            if (type === "string") {
+              return isOptional ? "String?" : "String";
+            }
+            if (type === "number") {
+              return isOptional ? "Int?" : "Int";
+            }
+            if (type === "boolean") {
+              return isOptional ? "Boolean?" : "Boolean";
+            }
+            if (type === "date") {
+              return isOptional ? "DateTime?" : "DateTime";
+            }
+          };
+          var getType = getType2;
+          const fields = tables[table].fields;
+          const tableName = tables[table].tableName;
+          const prismaModel = builder.findByType("model", {
+            name: tableName
+          });
+          !prismaModel && builder.model(tableName).field("id", "String").attribute("id");
+          for (const field in fields) {
+            const attr = fields[field];
+            if (prismaModel) {
+              const isAlreadyExist = builder.findByType("field", {
+                name: field,
+                within: prismaModel.properties
+              });
+              console.log(field, "exists");
+              if (isAlreadyExist) {
+                continue;
+              }
+            }
+            builder.model(tableName).field(field, getType2(attr.type, !attr.required));
+            if (attr.unique) {
+              builder.model(tableName).blockAttribute(`unique([${field}])`);
+            }
+            if (attr.references) {
+              builder.model(tableName).field(
+                capitalizeFirstLetter(attr.references.model),
+                attr.references.model
+              ).attribute(
+                `relation(fields: [${field}], references: [${attr.references.field}], onDelete: Cascade)`
+              );
+            }
+          }
+        }
+      });
+      return {
+        code: schema.trim() === schemaPrisma.trim() ? "" : schema,
+        fileName: filePath
+      };
+    }
+  };
+};
+var getNewPrisma = (provider) => `generator client {
   provider = "prisma-client-js"
 }
 
 datasource db {
-  provider = "${e}"
-  url      = ${e==="sqlite"?'"file:./dev.db"':'env("DATABASE_URL")'}
-}`;import{and as Q,eq as B,or as J}from"drizzle-orm";import*as P from"prettier";import{existsSync as Y}from"fs";import Z from"fs/promises";function T(e,o){let a=Object.keys(o).find(r=>{let s=o[r].name;return s===s});if(!a)throw new Error("Model not found");return o[a]}function q(e,o){if(!e)return[];if(e.length===1){let i=e[0];return i?[B(o[i.field],i.value)]:[]}let a=e.filter(i=>i.connector==="AND"||!i.connector),r=e.filter(i=>i.connector==="OR"),s=Q(...a.map(i=>B(o[i.field],i.value))),t=J(...r.map(i=>B(o[i.field],i.value))),n=[];return a.length&&n.push(s),r.length&&n.push(t),n}var ut=(e,o)=>{let a=o?.schema||e._.schema;if(!a)throw new w("Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.");let r=o?.provider;return{id:"drizzle",async create(s){let{model:t,data:n}=s,i=T(t,a);return(await e.insert(i).values(n).returning())[0]},async findOne(s){let{model:t,where:n,select:i}=s,c=T(t,a),l=q(n,c),d=null;return i?.length?d=await e.select(...i.map(u=>({[u]:c[u]}))).from(c).where(...l):d=await e.select().from(c).where(...l),d.length?d[0]:null},async findMany(s){let{model:t,where:n}=s,i=T(t,a),c=n?q(n,i):[];return await e.select().from(i).findMany(...c)},async update(s){let{model:t,where:n,update:i}=s,c=T(t,a),l=q(n,c);return(await e.update(c).set(i).where(...l).returning())[0]},async delete(s){let{model:t,where:n}=s,i=T(t,a),c=q(n,i);return(await e.delete(i).where(...c))[0]},async createSchema(s,t){let n=C(s),i=t||"./schema.ts",c=r!=="sqlite"?"timestamp, boolean":"",l=r==="mysql"?"int":"integer",d="",u=Y(i);if(u){let m=await Z.readFile(i,"utf-8");m.includes("import")?d=m:d=`import { ${r}Table, text, ${l}, ${c} } from "drizzle-orm/${r}-core";
-				`}else d=`import { ${r}Table, text, ${l}, ${c} } from "drizzle-orm/${r}-core";
-			`;for(let m in n){let y=function(A,x){if(x==="string")return`text('${A}')`;if(x==="number")return`${l}('${A}')`;if(x==="boolean")return r==="sqlite"?`integer('${A}', {
+  provider = "${provider}"
+  url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+}`;
+
+// src/adapters/drizzle-adapter/index.ts
+import { and, eq, or } from "drizzle-orm";
+import * as prettier from "prettier";
+import { existsSync as existsSync2 } from "fs";
+import fs2 from "fs/promises";
+function getSchema(modelName, schema) {
+  const key = Object.keys(schema).find((key2) => {
+    const modelName2 = schema[key2].name;
+    return modelName2 === modelName2;
+  });
+  if (!key) {
+    throw new Error("Model not found");
+  }
+  return schema[key];
+}
+function whereConvertor2(where, schemaModel) {
+  if (!where) return [];
+  if (where.length === 1) {
+    const w = where[0];
+    if (!w) {
+      return [];
+    }
+    return [eq(schemaModel[w.field], w.value)];
+  }
+  const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+  const orGroup = where.filter((w) => w.connector === "OR");
+  const andClause = and(
+    ...andGroup.map((w) => {
+      return eq(schemaModel[w.field], w.value);
+    })
+  );
+  const orClause = or(
+    ...orGroup.map((w) => {
+      return eq(schemaModel[w.field], w.value);
+    })
+  );
+  const clause = [];
+  if (andGroup.length) clause.push(andClause);
+  if (orGroup.length) clause.push(orClause);
+  return clause;
+}
+var drizzleAdapter = (db, options) => {
+  const schema = options?.schema || db._.schema;
+  if (!schema) {
+    throw new BetterAuthError(
+      "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
+    );
+  }
+  const databaseType = options?.provider;
+  return {
+    id: "drizzle",
+    async create(data) {
+      const { model, data: val } = data;
+      const schemaModel = getSchema(model, schema);
+      const res = await db.insert(schemaModel).values(val).returning();
+      return res[0];
+    },
+    async findOne(data) {
+      const { model, where, select: included } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = whereConvertor2(where, schemaModel);
+      let res = null;
+      if (!!included?.length) {
+        res = await db.select(
+          ...included.map((include) => {
+            return {
+              [include]: schemaModel[include]
+            };
+          })
+        ).from(schemaModel).where(...wheres);
+      } else {
+        res = await db.select().from(schemaModel).where(...wheres);
+      }
+      if (!!res.length) return res[0];
+      else return null;
+    },
+    async findMany(data) {
+      const { model, where } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = where ? whereConvertor2(where, schemaModel) : [];
+      return await db.select().from(schemaModel).findMany(...wheres);
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = whereConvertor2(where, schemaModel);
+      const res = await db.update(schemaModel).set(update).where(...wheres).returning();
+      return res[0];
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = whereConvertor2(where, schemaModel);
+      const res = await db.delete(schemaModel).where(...wheres);
+      return res[0];
+    },
+    async createSchema(options2, file) {
+      const tables = getAuthTables(options2);
+      const filePath = file || "./schema.ts";
+      const timestampAndBoolean = databaseType !== "sqlite" ? "timestamp, boolean" : "";
+      const int = databaseType === "mysql" ? "int" : "integer";
+      let code = `import { ${databaseType}Table, text, ${int}, ${timestampAndBoolean} } from "drizzle-orm/${databaseType}-core";
+			`;
+      const fileExist = existsSync2(filePath);
+      let fileContent = await fs2.readFile(filePath, "utf-8");
+      for (const table in tables) {
+        let getType2 = function(name, type) {
+          if (type === "string") {
+            return `text('${name}')`;
+          }
+          if (type === "number") {
+            return `${int}('${name}')`;
+          }
+          if (type === "boolean") {
+            if (databaseType === "sqlite") {
+              return `integer('${name}', {
 								mode: "boolean"
-							})`:`boolean('${A}')`;if(x==="date")return r==="sqlite"?`integer('${A}', {
+							})`;
+            }
+            return `boolean('${name}')`;
+          }
+          if (type === "date") {
+            if (databaseType === "sqlite") {
+              return `integer('${name}', {
 								mode: "timestamp"
-							})`:`timestamp('${A}')`};var g=y;let b=n[m].tableName,f=n[m].fields,h=`export const ${m} = ${r}Table("${b}", {
+							})`;
+            }
+            return `timestamp('${name}')`;
+          }
+        };
+        var getType = getType2;
+        const tableName = tables[table].tableName;
+        const fields = tables[table].fields;
+        const schema2 = `export const ${table} = ${databaseType}Table("${tableName}", {
 					id: text("id").primaryKey(),
-					${Object.keys(f).map(A=>{let x=f[A];return`${A}: ${y(A,x.type)}${x.required?".notNull()":""}${x.unique?".unique()":""}${x.references?`.references(()=> ${x.references.model}.${x.references.field})`:""}`}).join()}
-				});`;d+=`
-${h}
-`}return{code:await P.format(d,{semi:!0,parser:"typescript",tabWidth:4}),fileName:i,append:u}}}};function $(e){if(!e)return{};if(e.length===1){let n=e[0];return n?{[n.field]:n.value}:void 0}let o=e.filter(n=>n.connector==="AND"||!n.connector),a=e.filter(n=>n.connector==="OR"),r=o.map(n=>({[n.field]:n.operator==="eq"||!n.operator?n.value:{[n.field]:n.value}})),s=a.map(n=>({[n.field]:n.value})),t={};return r.length&&(t={...t,$and:r}),s.length&&(t={...t,$or:s}),t}function S(e){let{_id:o,...a}=e;return a}function ee(e){return e.reduce((a,r)=>(a[r]=1,a),{})}var pt=e=>{let o=e;return{id:"mongodb",async create(a){let{model:r,data:s}=a,i={id:(await o.collection(r).insertOne({...s})).insertedId,...s};return S(i)},async findOne(a){let{model:r,where:s,select:t}=a,n=$(s),i={};t&&(i=ee(t));let l=(await o.collection(r).find({...n},{projection:i}).toArray())[0];return l?S(l):null},async findMany(a){let{model:r,where:s}=a,t=$(s),n=await o.collection(r).findMany(t);return S(n)},async update(a){let{model:r,where:s,update:t}=a,n=$(s),i=await o.collection(r).findOneAndUpdate(n,{$set:t},{returnDocument:"after"});return S(i)},async delete(a){let{model:r,where:s}=a,t=$(s);return await o.collection(r).findOneAndDelete(t)}}};import"kysely";function te(e){return e.plugins?.flatMap(a=>Object.keys(a.schema||{}).map(r=>{let t=(a.schema||{})[r];if(!t?.disableMigration)return{tableName:r,fields:t?.fields}}).filter(r=>r!==void 0))||[]}function _(e){let o=C(e),a=te(e);return[o.user,o.session,o.account,...a].reduce((s,t)=>(s[t.tableName]={fields:{...s[t.tableName]?.fields,...t.fields}},s),{})}import{Kysely as re}from"kysely";import{MysqlDialect as L,PostgresDialect as M,SqliteDialect as F}from"kysely";var ne=async e=>{if(!e.database)return;if("createDriver"in e.database)return e.database;let o;if("provider"in e.database){let a=e.database.provider,r=e.database?.url?.trim();if(a==="postgres"){let t=(await import("pg").catch(n=>{throw new w("Please install `pg` to use postgres database")})).Pool;o=new M({pool:new t({connectionString:r})})}if(a==="mysql")try{let{createPool:s}=await import("mysql2/promise").catch(i=>{throw new w("Please install `mysql2` to use mysql database")}),t=new URL(r),n=s({host:t.hostname,user:t.username,password:t.password,database:t.pathname.split("/")[1],port:Number(t.port)});o=new L({pool:n})}catch(s){if(s instanceof TypeError)throw new w("Invalid database URL")}if(a==="sqlite")try{let s=await import("better-sqlite3").catch(i=>{throw new w("Please install `better-sqlite3` to use sqlite database")}),t=s.default||s;if(!t)throw new w("Failed to import better-sqlite3. Please ensure `better-sqlite3` is properly installed.");let n=new t(r);o=new F({database:n})}catch(s){throw console.error(s),new w("Failed to initialize SQLite. Please ensure `better-sqlite3` is properly installed.")}}return o},I=async e=>{let o=await ne(e);return o&&new re({dialect:o})},U=e=>{if("provider"in e.database)return e.database.provider;if("dialect"in e.database){if(e.database.dialect instanceof M)return"postgres";if(e.database.dialect instanceof L)return"mysql";if(e.database.dialect instanceof F)return"sqlite"}return"sqlite"};var oe={string:["character varying","text"],number:["int4","integer","bigint","smallint","numeric","real","double precision"],boolean:["bool","boolean"],date:["timestamp","date"]},se={string:["varchar","text"],number:["integer","int","bigint","smallint","decimal","float","double"],boolean:["boolean"],date:["date","datetime"]},ae={string:["TEXT"],number:["INTEGER","REAL"],boolean:["INTEGER","BOOLEAN"],date:["DATE","INTEGER"]},ie={postgres:oe,mysql:se,sqlite:ae};function ce(e,o,a){return ie[a][o].map(n=>n.toLowerCase()).includes(e.toLowerCase())}async function j(e){let o=_(e),a=U(e),r=await I(e);r||(N.error("Invalid database configuration."),process.exit(1));let s=await r.introspection.getTables(),t=[],n=[];for(let[u,p]of Object.entries(o)){let g=s.find(b=>b.name===u);if(!g){let b=t.findIndex(h=>h.table===u),f={table:u,fields:p.fields,order:p.order||1/0},y=t.findIndex(h=>(h.order||1/0)>f.order);y===-1?b===-1?t.push(f):t[b].fields={...t[b].fields,...p.fields}:t.splice(y,0,f);continue}let m={};for(let[b,f]of Object.entries(p.fields)){let y=g.columns.find(h=>h.name===b);if(!y){m[b]=f;continue}ce(y.dataType,f.type,a)||N.warn(`Field ${b} in table ${u} has a different type in the database. Expected ${f.type} but got ${y.dataType}.`)}Object.keys(m).length>0&&n.push({table:u,fields:m,order:p.order||1/0})}let i=[];function c(u){let p={string:"text",boolean:"boolean",number:"integer",date:"date"};return a==="mysql"&&u==="string"?"varchar(255)":p[u]}if(n.length)for(let u of n)for(let[p,g]of Object.entries(u.fields)){let m=c(g.type),b=r.schema.alterTable(u.table).addColumn(p,m,f=>(f=g.required!==!1?f.notNull():f,g.references&&(f=f.references(`${g.references.model}.${g.references.field}`)),f));i.push(b)}if(t.length)for(let u of t){let p=r.schema.createTable(u.table).addColumn("id",c("string"),g=>g.primaryKey());for(let[g,m]of Object.entries(u.fields)){let b=c(m.type);p=p.addColumn(g,b,f=>(f=m.required!==!1?f.notNull():f,m.references&&(f=f.references(`${m.references.model}.${m.references.field}`)),m.unique&&(f=f.unique()),f))}i.push(p)}async function l(){for(let u of i)await u.execute()}async function d(){return i.map(p=>p.compile().sql).join(`;
+					${Object.keys(fields).map((field) => {
+          const attr = fields[field];
+          return `${field}: ${getType2(field, attr.type)}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${attr.references.model}.${attr.references.field})` : ""}`;
+        }).join()}
+				});`;
+        code += `
+${schema2}
+`;
+      }
+      if (fileExist) {
+        if (fileContent.includes(code)) {
+          return {
+            code: "",
+            fileName: filePath,
+            append: false
+          };
+        }
+        if (fileContent.includes("import")) {
+          code = code.replace(/import {.*?} from "drizzle-orm\/.*?";/, "");
+        }
+      }
+      const formattedCode = await prettier.format(code, {
+        semi: true,
+        parser: "typescript",
+        tabWidth: 4
+      });
+      return {
+        code: formattedCode,
+        fileName: filePath,
+        append: fileExist
+      };
+    }
+  };
+};
 
-`)}return{toBeCreated:t,toBeAdded:n,runMigrations:l,compileMigrations:d}}function v(e){if(!e)return{and:null,or:null};let o=e?.filter(r=>r.connector==="AND"||!r.connector).reduce((r,s)=>({...r,[s.field]:s.value}),{}),a=e?.filter(r=>r.connector==="OR").reduce((r,s)=>({...r,[s.field]:s.value}),{});return{and:Object.keys(o).length?o:null,or:Object.keys(a).length?a:null}}function R(e,o,a){for(let r in e)e[r]===0&&o[r]?.type==="boolean"&&a?.boolean&&(e[r]=!1),e[r]===1&&o[r]?.type==="boolean"&&a?.boolean&&(e[r]=!0),o[r]?.type==="date"&&(e[r]instanceof Date||(e[r]=new Date(e[r])));return e}function z(e,o){for(let a in e)typeof e[a]=="boolean"&&o?.boolean&&(e[a]=e[a]?1:0),e[a]instanceof Date&&(e[a]=e[a].toISOString());return e}var St=(e,o)=>({id:"kysely",async create(a){let{model:r,data:s,select:t}=a;o?.transform&&(s=z(s,o.transform));let n=await e.insertInto(r).values(s).returningAll().executeTakeFirst();if(o?.transform){let i=o.transform.schema[r];n=i?R(s,i,o.transform):n}return t?.length&&(n=n?t.reduce((c,l)=>n?.[l]?{...c,[l]:n[l]}:c,{}):null),n},async findOne(a){let{model:r,where:s,select:t}=a,{and:n,or:i}=v(s),c=e.selectFrom(r).selectAll();i&&(c=c.where(d=>d.or(i))),n&&(c=c.where(d=>d.and(n)));let l=await c.executeTakeFirst();if(t?.length&&(l=l?t.reduce((u,p)=>l?.[p]?{...u,[p]:l[p]}:u,{}):null),o?.transform){let d=o.transform.schema[r];return l=l&&d?R(l,d,o.transform):l,l||null}return l||null},async findMany(a){let{model:r,where:s}=a,t=e.selectFrom(r),{and:n,or:i}=v(s);n&&(t=t.where(l=>l.and(n))),i&&(t=t.where(l=>l.or(i)));let c=await t.selectAll().execute();if(o?.transform){let l=o.transform.schema[r];return l?c.map(d=>R(d,l,o.transform)):c}return c},async update(a){let{model:r,where:s,update:t}=a,{and:n,or:i}=v(s);o?.transform&&(t=z(t,o.transform));let c=e.updateTable(r).set(t);n&&(c=c.where(d=>d.and(n))),i&&(c=c.where(d=>d.or(i)));let l=await c.returningAll().executeTakeFirst()||null;if(o?.transform){let d=o.transform.schema[r];return d?R(l,d,o.transform):l}return l},async delete(a){let{model:r,where:s}=a,{and:t,or:n}=v(s),i=e.deleteFrom(r);t&&(i=i.where(c=>c.and(t))),n&&(i=i.where(c=>c.or(n))),await i.execute()},async createSchema(a){let{compileMigrations:r}=await j(a);return console.log(r),{code:await r(),fileName:`./better-auth_migrations/${new Date().toISOString()}.sql`}}});export{ut as drizzleAdapter,St as kyselyAdapter,pt as mongodbAdapter,nt as prismaAdapter};
+// src/adapters/mongodb-adapter/index.ts
+function whereConvertor3(where) {
+  if (!where) return {};
+  if (where.length === 1) {
+    const w = where[0];
+    if (!w) {
+      return;
+    }
+    return {
+      [w.field]: w.value
+    };
+  }
+  const and2 = where.filter((w) => w.connector === "AND" || !w.connector);
+  const or2 = where.filter((w) => w.connector === "OR");
+  const andClause = and2.map((w) => {
+    return {
+      [w.field]: w.operator === "eq" || !w.operator ? w.value : {
+        [w.field]: w.value
+      }
+    };
+  });
+  const orClause = or2.map((w) => {
+    return {
+      [w.field]: w.value
+    };
+  });
+  let clause = {};
+  if (andClause.length) {
+    clause = { ...clause, $and: andClause };
+  }
+  if (orClause.length) {
+    clause = { ...clause, $or: orClause };
+  }
+  return clause;
+}
+function removeMongoId(data) {
+  const { _id, ...rest } = data;
+  return rest;
+}
+function selectConvertor(selects) {
+  const selectConstruct = selects.reduce((acc, field) => {
+    acc[field] = 1;
+    return acc;
+  }, {});
+  return selectConstruct;
+}
+var mongodbAdapter = (mongo) => {
+  const db = mongo;
+  return {
+    id: "mongodb",
+    async create(data) {
+      const { model, data: val } = data;
+      const res = await db.collection(model).insertOne({
+        ...val
+      });
+      const id_ = res.insertedId;
+      const returned = { id: id_, ...val };
+      return removeMongoId(returned);
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const wheres = whereConvertor3(where);
+      let selects = {};
+      if (select) {
+        selects = selectConvertor(select);
+      }
+      const res = await db.collection(model).find({ ...wheres }, { projection: selects }).toArray();
+      const result = res[0];
+      if (!result) {
+        return null;
+      }
+      return removeMongoId(result);
+    },
+    async findMany(data) {
+      const { model, where } = data;
+      const wheres = whereConvertor3(where);
+      const toReturn = await db.collection(model).findMany(wheres);
+      return removeMongoId(toReturn);
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      const wheres = whereConvertor3(where);
+      const res = await db.collection(model).findOneAndUpdate(
+        wheres,
+        {
+          $set: update
+        },
+        { returnDocument: "after" }
+      );
+      return removeMongoId(res);
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const wheres = whereConvertor3(where);
+      const res = await db.collection(model).findOneAndDelete(wheres);
+      return res;
+    }
+  };
+};
+
+// src/cli/utils/get-migration.ts
+import "kysely";
+
+// src/cli/utils/get-schema.ts
+function getPluginTable(config) {
+  const pluginsMigrations = config.plugins?.flatMap(
+    (plugin) => Object.keys(plugin.schema || {}).map((key) => {
+      const schema = plugin.schema || {};
+      const table = schema[key];
+      if (table?.disableMigration) {
+        return;
+      }
+      return {
+        tableName: key,
+        fields: table?.fields
+      };
+    }).filter((value) => value !== void 0)
+  ) || [];
+  return pluginsMigrations;
+}
+function getSchema2(config) {
+  const baseSchema = getAuthTables(config);
+  const pluginSchema = getPluginTable(config);
+  const schema = [
+    baseSchema.user,
+    baseSchema.session,
+    baseSchema.account,
+    ...pluginSchema
+  ].reduce((acc, curr) => {
+    acc[curr.tableName] = {
+      fields: {
+        ...acc[curr.tableName]?.fields,
+        ...curr.fields
+      }
+    };
+    return acc;
+  }, {});
+  return schema;
+}
+
+// src/adapters/kysely-adapter/dialect.ts
+import { Kysely } from "kysely";
+import {
+  MysqlDialect,
+  PostgresDialect,
+  SqliteDialect
+} from "kysely";
+import "execa";
+import "prompts";
+
+// src/cli/utils/get-package-manager.ts
+import { detect } from "@antfu/ni";
+
+// src/adapters/kysely-adapter/dialect.ts
+import "ora";
+var getDialect = async (config, isCli) => {
+  if (!config.database) {
+    return void 0;
+  }
+  if ("createDriver" in config.database) {
+    return config.database;
+  }
+  let dialect = void 0;
+  if ("provider" in config.database) {
+    const provider = config.database.provider;
+    const connectionString = config.database?.url?.trim();
+    if (provider === "postgres") {
+      const pg = await import("pg").catch(async (e) => {
+        throw new MissingDependencyError("pg");
+      });
+      const Pool = pg.default?.Pool || pg.Pool;
+      const pool = new Pool({
+        connectionString
+      });
+      dialect = new PostgresDialect({
+        pool
+      });
+    }
+    if (provider === "mysql") {
+      try {
+        const { createPool } = await import("mysql2/promise").catch(
+          async (e) => {
+            throw new MissingDependencyError("mysql2");
+          }
+        );
+        const params = new URL(connectionString);
+        const pool = createPool({
+          host: params.hostname,
+          user: params.username,
+          password: params.password,
+          database: params.pathname.split("/")[1],
+          port: Number(params.port)
+        });
+        dialect = new MysqlDialect({ pool });
+      } catch (e) {
+        if (e instanceof TypeError) {
+          throw new BetterAuthError("Invalid database URL");
+        }
+        throw e;
+      }
+    }
+    if (provider === "sqlite") {
+      try {
+        const database = await import("better-sqlite3").catch(async (e) => {
+          throw new MissingDependencyError("better-sqlite3");
+        });
+        const Database = database.default || database;
+        const db = new Database(connectionString);
+        dialect = new SqliteDialect({
+          database: db
+        });
+      } catch (e) {
+        console.error(e);
+        throw new BetterAuthError(
+          "Failed to initialize SQLite. Make sure `better-sqlite3` is properly installed."
+        );
+      }
+    }
+  }
+  return dialect;
+};
+var createKyselyAdapter = async (config, isCli) => {
+  const dialect = await getDialect(config, isCli);
+  if (!dialect) {
+    return dialect;
+  }
+  const db = new Kysely({
+    dialect
+  });
+  return db;
+};
+var getDatabaseType = (config) => {
+  if ("provider" in config.database) {
+    return config.database.provider;
+  }
+  if ("dialect" in config.database) {
+    if (config.database.dialect instanceof PostgresDialect) {
+      return "postgres";
+    }
+    if (config.database.dialect instanceof MysqlDialect) {
+      return "mysql";
+    }
+    if (config.database.dialect instanceof SqliteDialect) {
+      return "sqlite";
+    }
+  }
+  return "sqlite";
+};
+
+// src/cli/utils/get-migration.ts
+var postgresMap = {
+  string: ["character varying", "text"],
+  number: [
+    "int4",
+    "integer",
+    "bigint",
+    "smallint",
+    "numeric",
+    "real",
+    "double precision"
+  ],
+  boolean: ["bool", "boolean"],
+  date: ["timestamp", "date"]
+};
+var mysqlMap = {
+  string: ["varchar", "text"],
+  number: [
+    "integer",
+    "int",
+    "bigint",
+    "smallint",
+    "decimal",
+    "float",
+    "double"
+  ],
+  boolean: ["boolean"],
+  date: ["date", "datetime"]
+};
+var sqliteMap = {
+  string: ["TEXT"],
+  number: ["INTEGER", "REAL"],
+  boolean: ["INTEGER", "BOOLEAN"],
+  // 0 or 1
+  date: ["DATE", "INTEGER"]
+};
+var map = {
+  postgres: postgresMap,
+  mysql: mysqlMap,
+  sqlite: sqliteMap
+};
+function matchType(columnDataType, fieldType, dbType) {
+  const types = map[dbType];
+  const type = types[fieldType].map((t) => t.toLowerCase());
+  const matches = type.includes(columnDataType.toLowerCase());
+  return matches;
+}
+async function getMigrations(config) {
+  const betterAuthSchema = getSchema2(config);
+  const dbType = getDatabaseType(config);
+  const db = await createKyselyAdapter(config);
+  if (!db) {
+    logger.error("Invalid database configuration.");
+    process.exit(1);
+  }
+  const tableMetadata = await db.introspection.getTables();
+  const toBeCreated = [];
+  const toBeAdded = [];
+  for (const [key, value] of Object.entries(betterAuthSchema)) {
+    const table = tableMetadata.find((t) => t.name === key);
+    if (!table) {
+      const tIndex = toBeCreated.findIndex((t) => t.table === key);
+      const tableData = {
+        table: key,
+        fields: value.fields,
+        order: value.order || Infinity
+      };
+      const insertIndex = toBeCreated.findIndex(
+        (t) => (t.order || Infinity) > tableData.order
+      );
+      if (insertIndex === -1) {
+        if (tIndex === -1) {
+          toBeCreated.push(tableData);
+        } else {
+          toBeCreated[tIndex].fields = {
+            ...toBeCreated[tIndex].fields,
+            ...value.fields
+          };
+        }
+      } else {
+        toBeCreated.splice(insertIndex, 0, tableData);
+      }
+      continue;
+    }
+    let toBeAddedFields = {};
+    for (const [fieldName, field] of Object.entries(value.fields)) {
+      const column = table.columns.find((c) => c.name === fieldName);
+      if (!column) {
+        toBeAddedFields[fieldName] = field;
+        continue;
+      }
+      if (matchType(column.dataType, field.type, dbType)) {
+        continue;
+      } else {
+        logger.warn(
+          `Field ${fieldName} in table ${key} has a different type in the database. Expected ${field.type} but got ${column.dataType}.`
+        );
+      }
+    }
+    if (Object.keys(toBeAddedFields).length > 0) {
+      toBeAdded.push({
+        table: key,
+        fields: toBeAddedFields,
+        order: value.order || Infinity
+      });
+    }
+  }
+  const migrations = [];
+  function getType(type) {
+    const typeMap = {
+      string: "text",
+      boolean: "boolean",
+      number: "integer",
+      date: "date"
+    };
+    if (dbType === "mysql" && type === "string") {
+      return "varchar(255)";
+    }
+    return typeMap[type];
+  }
+  if (toBeAdded.length) {
+    for (const table of toBeAdded) {
+      for (const [fieldName, field] of Object.entries(table.fields)) {
+        const type = getType(field.type);
+        const exec = db.schema.alterTable(table.table).addColumn(fieldName, type, (col) => {
+          col = field.required !== false ? col.notNull() : col;
+          if (field.references) {
+            col = col.references(
+              `${field.references.model}.${field.references.field}`
+            );
+          }
+          return col;
+        });
+        migrations.push(exec);
+      }
+    }
+  }
+  if (toBeCreated.length) {
+    for (const table of toBeCreated) {
+      let dbT = db.schema.createTable(table.table).addColumn("id", getType("string"), (col) => col.primaryKey());
+      for (const [fieldName, field] of Object.entries(table.fields)) {
+        const type = getType(field.type);
+        dbT = dbT.addColumn(fieldName, type, (col) => {
+          col = field.required !== false ? col.notNull() : col;
+          if (field.references) {
+            col = col.references(
+              `${field.references.model}.${field.references.field}`
+            );
+          }
+          if (field.unique) {
+            col = col.unique();
+          }
+          return col;
+        });
+      }
+      migrations.push(dbT);
+    }
+  }
+  async function runMigrations() {
+    for (const migration of migrations) {
+      await migration.execute();
+    }
+  }
+  async function compileMigrations() {
+    const compiled = migrations.map((m) => m.compile().sql);
+    return compiled.join(";\n\n");
+  }
+  return { toBeCreated, toBeAdded, runMigrations, compileMigrations };
+}
+
+// src/adapters/kysely-adapter/index.ts
+function convertWhere(w) {
+  if (!w)
+    return {
+      and: null,
+      or: null
+    };
+  const and2 = w?.filter((w2) => w2.connector === "AND" || !w2.connector).reduce(
+    (acc, w2) => ({
+      ...acc,
+      [w2.field]: w2.value
+    }),
+    {}
+  );
+  const or2 = w?.filter((w2) => w2.connector === "OR").reduce(
+    (acc, w2) => ({
+      ...acc,
+      [w2.field]: w2.value
+    }),
+    {}
+  );
+  return {
+    and: Object.keys(and2).length ? and2 : null,
+    or: Object.keys(or2).length ? or2 : null
+  };
+}
+function transformTo(val, fields, transform) {
+  for (const key in val) {
+    if (val[key] === 0 && fields[key]?.type === "boolean" && transform?.boolean) {
+      val[key] = false;
+    }
+    if (val[key] === 1 && fields[key]?.type === "boolean" && transform?.boolean) {
+      val[key] = true;
+    }
+    if (fields[key]?.type === "date") {
+      if (!(val[key] instanceof Date)) {
+        val[key] = new Date(val[key]);
+      }
+    }
+  }
+  return val;
+}
+function transformFrom(val, transform) {
+  for (const key in val) {
+    if (typeof val[key] === "boolean" && transform?.boolean) {
+      val[key] = val[key] ? 1 : 0;
+    }
+    if (val[key] instanceof Date) {
+      val[key] = val[key].toISOString();
+    }
+  }
+  return val;
+}
+var kyselyAdapter = (db, config) => {
+  return {
+    id: "kysely",
+    async create(data) {
+      let { model, data: val, select } = data;
+      if (config?.transform) {
+        val = transformFrom(val, config.transform);
+      }
+      let res = await db.insertInto(model).values(val).returningAll().executeTakeFirst();
+      if (config?.transform) {
+        const schema = config.transform.schema[model];
+        res = schema ? transformTo(val, schema, config.transform) : res;
+      }
+      if (select?.length) {
+        const data2 = res ? select.reduce((acc, cur) => {
+          if (res?.[cur]) {
+            return {
+              ...acc,
+              [cur]: res[cur]
+            };
+          }
+          return acc;
+        }, {}) : null;
+        res = data2;
+      }
+      return res;
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const { and: and2, or: or2 } = convertWhere(where);
+      let query = db.selectFrom(model).selectAll();
+      if (or2) {
+        query = query.where((eb) => eb.or(or2));
+      }
+      if (and2) {
+        query = query.where((eb) => eb.and(and2));
+      }
+      let res = await query.executeTakeFirst();
+      if (select?.length) {
+        const data2 = res ? select.reduce((acc, cur) => {
+          if (res?.[cur]) {
+            return {
+              ...acc,
+              [cur]: res[cur]
+            };
+          }
+          return acc;
+        }, {}) : null;
+        res = data2;
+      }
+      if (config?.transform) {
+        const schema = config.transform.schema[model];
+        res = res && schema ? transformTo(res, schema, config.transform) : res;
+        return res || null;
+      }
+      return res || null;
+    },
+    async findMany(data) {
+      const { model, where } = data;
+      let query = db.selectFrom(model);
+      const { and: and2, or: or2 } = convertWhere(where);
+      if (and2) {
+        query = query.where((eb) => eb.and(and2));
+      }
+      if (or2) {
+        query = query.where((eb) => eb.or(or2));
+      }
+      const res = await query.selectAll().execute();
+      if (config?.transform) {
+        const schema = config.transform.schema[model];
+        return schema ? res.map((v) => transformTo(v, schema, config.transform)) : res;
+      }
+      return res;
+    },
+    async update(data) {
+      let { model, where, update: val } = data;
+      const { and: and2, or: or2 } = convertWhere(where);
+      if (config?.transform) {
+        val = transformFrom(val, config.transform);
+      }
+      let query = db.updateTable(model).set(val);
+      if (and2) {
+        query = query.where((eb) => eb.and(and2));
+      }
+      if (or2) {
+        query = query.where((eb) => eb.or(or2));
+      }
+      const res = await query.returningAll().executeTakeFirst() || null;
+      if (config?.transform) {
+        const schema = config.transform.schema[model];
+        return schema ? transformTo(res, schema, config.transform) : res;
+      }
+      return res;
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const { and: and2, or: or2 } = convertWhere(where);
+      let query = db.deleteFrom(model);
+      if (and2) {
+        query = query.where((eb) => eb.and(and2));
+      }
+      if (or2) {
+        query = query.where((eb) => eb.or(or2));
+      }
+      await query.execute();
+    },
+    async createSchema(options) {
+      const { compileMigrations } = await getMigrations(options);
+      const migrations = await compileMigrations();
+      return {
+        code: migrations,
+        fileName: `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString()}.sql`
+      };
+    }
+  };
+};
+export {
+  drizzleAdapter,
+  kyselyAdapter,
+  mongodbAdapter,
+  prismaAdapter
+};