better-auth 0.2.3-beta.8 → 0.2.4

package/dist/cli.js

@@ -1,5 +1,1012 @@
 #!/usr/bin/env node
-import{Command as ye}from"commander";import"dotenv/config";import{Command as le}from"commander";import{loadConfig as I}from"c12";import{createConsola as _}from"consola";var A=_({formatOptions:{date:!1,colors:!0,compact:!0},defaults:{tag:"Better Auth"}}),H=e=>({log:(...t)=>{!e?.disabled&&A.log("",...t)},error:(...t)=>{!e?.disabled&&A.error("",...t)},warn:(...t)=>{!e?.disabled&&A.warn("",...t)},info:(...t)=>{!e?.disabled&&A.info("",...t)},debug:(...t)=>{!e?.disabled&&A.debug("",...t)},box:(...t)=>{!e?.disabled&&A.box("",...t)},success:(...t)=>{!e?.disabled&&A.success("",...t)},break:(...t)=>{!e?.disabled&&console.log(`
-`)}}),c=H();import J from"path";import Y from"@babel/preset-typescript";import Z from"@babel/preset-react";var w=["auth.ts","auth.tsx"];w=[...w,...w.map(e=>`lib/${e}`),...w.map(e=>`utils/${e}`)];w=[...w,...w.map(e=>`src/${e}`)];var E={transformOptions:{babel:{presets:[[Y,{isTSX:!0,allExtensions:!0}],[Z,{runtime:"automatic"}]]}},extensions:[".ts",".tsx",".js",".jsx"]};async function B({cwd:e,configPath:t}){try{let a=null;if(t){let{config:r}=await I({configFile:J.join(e,t),dotenv:!0,jitiOptions:E});!r.auth&&!r.default&&(c.error("[#better-auth]: Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth."),process.exit(1)),a=r.auth?.options||r.default?.options||null}if(!a)for(let r of w)try{let{config:i}=await I({configFile:r,jitiOptions:E});if(Object.keys(i).length>0){a=i.auth?.options||i.default?.options||null,a||(c.error("[#better-auth]: Couldn't read your auth config."),c.break(),c.info("[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth."),process.exit(1));break}}catch(i){c.error(i),process.exit(1)}return a}catch(a){c.error("Error while reading your auth config.",a),process.exit(1)}}import{z as M}from"zod";import{existsSync as de}from"fs";import ce from"path";import{Kysely as ee}from"kysely";import{MysqlDialect as $,PostgresDialect as P,SqliteDialect as L}from"kysely";var g=class extends Error{constructor(t,a,r){super(t),this.name="BetterAuthError",this.message=t,this.cause=a}};var te=async e=>{if(!e.database)return;if("createDriver"in e.database)return e.database;let t;if("provider"in e.database){let a=e.database.provider,r=e.database?.url?.trim();if(a==="postgres"){let o=(await import("pg").catch(s=>{throw new g("Please install `pg` to use postgres database")})).Pool;t=new P({pool:new o({connectionString:r})})}if(a==="mysql")try{let{createPool:i}=await import("mysql2/promise").catch(n=>{throw new g("Please install `mysql2` to use mysql database")}),o=new URL(r),s=i({host:o.hostname,user:o.username,password:o.password,database:o.pathname.split("/")[1],port:Number(o.port)});t=new $({pool:s})}catch(i){if(i instanceof TypeError)throw new g("Invalid database URL")}if(a==="sqlite")try{let i=await import("better-sqlite3").catch(n=>{throw new g("Please install `better-sqlite3` to use sqlite database")}),o=i.default||i;if(!o)throw new g("Failed to import better-sqlite3. Please ensure `better-sqlite3` is properly installed.");let s=new o(r);t=new L({database:s})}catch(i){throw console.error(i),new g("Failed to initialize SQLite. Please ensure `better-sqlite3` is properly installed.")}}return t},T=async e=>{let t=await te(e);return t&&new ee({dialect:t})},F=e=>{if("provider"in e.database)return e.database.provider;if("dialect"in e.database){if(e.database.dialect instanceof P)return"postgres";if(e.database.dialect instanceof $)return"mysql";if(e.database.dialect instanceof L)return"sqlite"}return"sqlite"};import ue from"ora";import N from"chalk";import fe from"prompts";import"kysely";var k=e=>{let t=e.plugins?.reduce((l,d)=>{let f=d.schema;if(!f)return l;for(let[u,m]of Object.entries(f))l[u]={fields:{...l[u]?.fields,...m.fields},tableName:u};return l},{}),a=e.rateLimit?.storage==="database",r={rateLimit:{tableName:e.rateLimit?.tableName||"rateLimit",fields:{key:{type:"string"},count:{type:"number"},lastRequest:{type:"number"}}}},{user:i,session:o,account:s,...n}=t||{};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},...i?.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},...o?.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},...s?.fields},order:2},...n,...a?r:{}}};function re(e){return e.plugins?.flatMap(a=>Object.keys(a.schema||{}).map(r=>{let o=(a.schema||{})[r];if(!o?.disableMigration)return{tableName:r,fields:o?.fields}}).filter(r=>r!==void 0))||[]}function v(e){let t=k(e),a=re(e);return[t.user,t.session,t.account,...a].reduce((i,o)=>(i[o.tableName]={fields:{...i[o.tableName]?.fields,...o.fields}},i),{})}var ae={string:["character varying","text"],number:["int4","integer","bigint","smallint","numeric","real","double precision"],boolean:["bool","boolean"],date:["timestamp","date"]},oe={string:["varchar","text"],number:["integer","int","bigint","smallint","decimal","float","double"],boolean:["boolean"],date:["date","datetime"]},ie={string:["TEXT"],number:["INTEGER","REAL"],boolean:["INTEGER","BOOLEAN"],date:["DATE","INTEGER"]},se={postgres:ae,mysql:oe,sqlite:ie};function ne(e,t,a){return se[a][t].map(s=>s.toLowerCase()).includes(e.toLowerCase())}async function D(e){let t=v(e),a=F(e),r=await T(e);r||(c.error("Invalid database configuration."),process.exit(1));let i=await r.introspection.getTables(),o=[],s=[];for(let[u,m]of Object.entries(t)){let h=i.find(y=>y.name===u);if(!h){let y=o.findIndex(O=>O.table===u),p={table:u,fields:m.fields,order:m.order||1/0},q=o.findIndex(O=>(O.order||1/0)>p.order);q===-1?y===-1?o.push(p):o[y].fields={...o[y].fields,...m.fields}:o.splice(q,0,p);continue}let b={};for(let[y,p]of Object.entries(m.fields)){let q=h.columns.find(O=>O.name===y);if(!q){b[y]=p;continue}ne(q.dataType,p.type,a)||c.warn(`Field ${y} in table ${u} has a different type in the database. Expected ${p.type} but got ${q.dataType}.`)}Object.keys(b).length>0&&s.push({table:u,fields:b,order:m.order||1/0})}let n=[];function l(u){let m={string:"text",boolean:"boolean",number:"integer",date:"date"};return a==="mysql"&&u==="string"?"varchar(255)":m[u]}if(s.length)for(let u of s)for(let[m,h]of Object.entries(u.fields)){let b=l(h.type),y=r.schema.alterTable(u.table).addColumn(m,b,p=>(p=h.required!==!1?p.notNull():p,h.references&&(p=p.references(`${h.references.model}.${h.references.field}`)),p));n.push(y)}if(o.length)for(let u of o){let m=r.schema.createTable(u.table).addColumn("id",l("string"),h=>h.primaryKey());for(let[h,b]of Object.entries(u.fields)){let y=l(b.type);m=m.addColumn(h,y,p=>(p=b.required!==!1?p.notNull():p,b.references&&(p=p.references(`${b.references.model}.${b.references.field}`)),b.unique&&(p=p.unique()),p))}n.push(m)}async function d(){for(let u of n)await u.execute()}async function f(){return n.map(m=>m.compile().sql).join(`;
 
-`)}return{toBeCreated:o,toBeAdded:s,runMigrations:d,compileMigrations:f}}var K=new le("migrate").option("-c, --cwd <cwd>","the working directory. defaults to the current directory.",process.cwd()).option("--config <config>","the path to the configuration file. defaults to the first configuration file found.").option("--y","").action(async e=>{let t=M.object({cwd:M.string(),config:M.string().optional()}).parse(e),a=ce.resolve(t.cwd);de(a)||(c.error(`The directory "${a}" does not exist.`),process.exit(1));let r=await B({cwd:a,configPath:t.config});if(!r){c.error("No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");return}await T(r)||(c.error("Invalid database configuration."),process.exit(1));let o=ue("preparing migration...").start(),{toBeAdded:s,toBeCreated:n,runMigrations:l}=await D(r);!s.length&&!n.length&&(o.stop(),c.success("\u{1F680} No migrations needed."),process.exit(0)),o.stop(),c.info("\u{1F511} The migration will affect the following:");for(let f of[...n,...s])c.info("->",N.magenta(Object.keys(f.fields).join(", ")),N.white("fields on"),N.yellow(`${f.table}`),N.white("table."));let{migrate:d}=await fe({type:"confirm",name:"migrate",message:"Are you sure you want to run these migrations?",initial:!1});d||(c.info("Migration cancelled."),process.exit(0)),o?.start("migrating..."),await l(),o.stop(),c.success("\u{1F680} migration was completed successfully!"),process.exit(0)});import{Command as pe}from"commander";import{z as j}from"zod";import{existsSync as W}from"fs";import x from"path";import me from"ora";import U from"prompts";function C(e){if(!e)return{and:null,or:null};let t=e?.filter(r=>r.connector==="AND"||!r.connector).reduce((r,i)=>({...r,[i.field]:i.value}),{}),a=e?.filter(r=>r.connector==="OR").reduce((r,i)=>({...r,[i.field]:i.value}),{});return{and:Object.keys(t).length?t:null,or:Object.keys(a).length?a:null}}function S(e,t,a){for(let r in e)e[r]===0&&t[r]?.type==="boolean"&&a?.boolean&&(e[r]=!1),e[r]===1&&t[r]?.type==="boolean"&&a?.boolean&&(e[r]=!0),t[r]?.type==="date"&&(e[r]instanceof Date||(e[r]=new Date(e[r])));return e}function z(e,t){for(let a in e)typeof e[a]=="boolean"&&t?.boolean&&(e[a]=e[a]?1:0),e[a]instanceof Date&&(e[a]=e[a].toISOString());return e}var V=(e,t)=>({id:"kysely",async create(a){let{model:r,data:i,select:o}=a;t?.transform&&(i=z(i,t.transform));let s=await e.insertInto(r).values(i).returningAll().executeTakeFirst();if(t?.transform){let n=t.transform.schema[r];s=n?S(i,n,t.transform):s}return o?.length&&(s=s?o.reduce((l,d)=>s?.[d]?{...l,[d]:s[d]}:l,{}):null),s},async findOne(a){let{model:r,where:i,select:o}=a,{and:s,or:n}=C(i),l=e.selectFrom(r).selectAll();n&&(l=l.where(f=>f.or(n))),s&&(l=l.where(f=>f.and(s)));let d=await l.executeTakeFirst();if(o?.length&&(d=d?o.reduce((u,m)=>d?.[m]?{...u,[m]:d[m]}:u,{}):null),t?.transform){let f=t.transform.schema[r];return d=d&&f?S(d,f,t.transform):d,d||null}return d||null},async findMany(a){let{model:r,where:i}=a,o=e.selectFrom(r),{and:s,or:n}=C(i);s&&(o=o.where(d=>d.and(s))),n&&(o=o.where(d=>d.or(n)));let l=await o.selectAll().execute();if(t?.transform){let d=t.transform.schema[r];return d?l.map(f=>S(f,d,t.transform)):l}return l},async update(a){let{model:r,where:i,update:o}=a,{and:s,or:n}=C(i);t?.transform&&(o=z(o,t.transform));let l=e.updateTable(r).set(o);s&&(l=l.where(f=>f.and(s))),n&&(l=l.where(f=>f.or(n)));let d=await l.returningAll().executeTakeFirst()||null;if(t?.transform){let f=t.transform.schema[r];return f?S(d,f,t.transform):d}return d},async delete(a){let{model:r,where:i}=a,{and:o,or:s}=C(i),n=e.deleteFrom(r);o&&(n=n.where(l=>l.and(o))),s&&(n=n.where(l=>l.or(s))),await n.execute()},async createSchema(a){let{compileMigrations:r}=await D(a);return console.log(r),{code:await r(),fileName:`./better-auth_migrations/${new Date().toISOString()}.sql`}}});async function G(e){if(!e.database)throw new g("Database configuration is required");if("create"in e.database)return e.database;let t=await T(e);if(!t)throw new g("Failed to initialize database adapter");let a=k(e),r={};for(let i of Object.values(a))r[i.tableName]=i.fields;return V(t,{transform:{schema:r,date:!0,boolean:F(e)==="sqlite"}})}import R from"fs/promises";import X from"chalk";var Q=new pe("generate").option("-c, --cwd <cwd>","the working directory. defaults to the current directory.",process.cwd()).option("--config <config>","the path to the configuration file. defaults to the first configuration file found.").option("--out <output>","the file to output to the generated schema").option("--y","").action(async e=>{let t=j.object({cwd:j.string(),config:j.string().optional(),out:j.string().optional()}).parse(e),a=x.resolve(t.cwd);W(a)||(c.error(`The directory "${a}" does not exist.`),process.exit(1));let r=await B({cwd:a,configPath:t.config});if(!r){c.error("No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");return}let i=await G(r);i.createSchema||(c.error("The adapter does not support schema generation."),process.exit(1));let o=me("preparing schema...").start(),{code:s,fileName:n,append:l}=await i.createSchema(r,t.out);if(o.stop(),l){let{append:u}=await U({type:"confirm",name:"append",message:`The file ${n} already exists. Do you want to ${X.yellow("append")} the schema to the file?`});u?(await R.appendFile(x.join(a,n),s),c.success("\u{1F680} schema was appended successfully!"),process.exit(0)):(c.error("Schema generation aborted."),process.exit(1))}let{confirm:d}=await U({type:"confirm",name:"confirm",message:`Do you want to generate the schema to ${X.yellow(n)}?`});d||(c.error("Schema generation aborted."),process.exit(1)),W(x.dirname(x.join(a,n)))||await R.mkdir(x.dirname(x.join(a,n)),{recursive:!0}),await R.writeFile(t.out||x.join(a,n),s),c.success("\u{1F680} schema was generated successfully!"),process.exit(0)});async function he(){let e=new ye().name("better-auth");e.addCommand(K).addCommand(Q),e.parse()}he();
+// src/cli/index.ts
+import { Command as Command3 } from "commander";
+import "dotenv/config";
+
+// src/cli/commands/migrate.ts
+import { Command } from "commander";
+
+// src/cli/get-config.ts
+import { loadConfig } from "c12";
+
+// 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/cli/get-config.ts
+import path from "path";
+import babelPresetTypescript from "@babel/preset-typescript";
+import babelPresetReact from "@babel/preset-react";
+var possiblePaths = ["auth.ts", "auth.tsx"];
+possiblePaths = [
+  ...possiblePaths,
+  ...possiblePaths.map((it) => `lib/${it}`),
+  ...possiblePaths.map((it) => `utils/${it}`)
+];
+possiblePaths = [...possiblePaths, ...possiblePaths.map((it) => `src/${it}`)];
+var jitiOptions = {
+  transformOptions: {
+    babel: {
+      presets: [
+        [babelPresetTypescript, { isTSX: true, allExtensions: true }],
+        [babelPresetReact, { runtime: "automatic" }]
+      ]
+    }
+  },
+  extensions: [".ts", ".tsx", ".js", ".jsx"]
+};
+async function getConfig({
+  cwd,
+  configPath
+}) {
+  try {
+    let configFile = null;
+    if (configPath) {
+      const { config } = await loadConfig({
+        configFile: path.join(cwd, configPath),
+        dotenv: true,
+        jitiOptions
+      });
+      if (!config.auth && !config.default) {
+        logger.error(
+          "[#better-auth]: Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth."
+        );
+        process.exit(1);
+      }
+      configFile = config.auth?.options || config.default?.options || null;
+    }
+    if (!configFile) {
+      for (const possiblePath of possiblePaths) {
+        try {
+          const { config } = await loadConfig({
+            configFile: possiblePath,
+            jitiOptions
+          });
+          const hasConfig = Object.keys(config).length > 0;
+          if (hasConfig) {
+            configFile = config.auth?.options || config.default?.options || null;
+            if (!configFile) {
+              logger.error("[#better-auth]: Couldn't read your auth config.");
+              logger.break();
+              logger.info(
+                "[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth."
+              );
+              process.exit(1);
+            }
+            break;
+          }
+        } catch (e) {
+          process.exit(1);
+        }
+      }
+    }
+    return configFile;
+  } catch (e) {
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/migrate.ts
+import { z } from "zod";
+import { existsSync } from "fs";
+import path2 from "path";
+
+// src/adapters/kysely-adapter/dialect.ts
+import { Kysely } from "kysely";
+import {
+  MysqlDialect,
+  PostgresDialect,
+  SqliteDialect
+} from "kysely";
+
+// 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/adapters/kysely-adapter/dialect.ts
+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/commands/migrate.ts
+import ora3 from "ora";
+import chalk from "chalk";
+import prompts3 from "prompts";
+
+// src/cli/utils/get-migration.ts
+import "kysely";
+
+// 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/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 getSchema(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/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 = getSchema(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/cli/utils/install-dep.ts
+import ora2 from "ora";
+import prompts2 from "prompts";
+import { execa as execa2 } from "execa";
+
+// src/cli/commands/migrate.ts
+var migrate = new Command("migrate").option(
+  "-c, --cwd <cwd>",
+  "the working directory. defaults to the current directory.",
+  process.cwd()
+).option(
+  "--config <config>",
+  "the path to the configuration file. defaults to the first configuration file found."
+).option("--y", "").action(async (opts) => {
+  const options = z.object({
+    cwd: z.string(),
+    config: z.string().optional()
+  }).parse(opts);
+  const cwd = path2.resolve(options.cwd);
+  if (!existsSync(cwd)) {
+    logger.error(`The directory "${cwd}" does not exist.`);
+    process.exit(1);
+  }
+  const config = await getConfig({
+    cwd,
+    configPath: options.config
+  });
+  if (!config) {
+    logger.error(
+      "No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag."
+    );
+    return;
+  }
+  const db = await createKyselyAdapter(config, true).catch((e) => {
+    logger.error(e.message);
+    process.exit(1);
+  });
+  if (!db) {
+    logger.error("Invalid database configuration.");
+    process.exit(1);
+  }
+  const spinner = ora3("preparing migration...").start();
+  const { toBeAdded, toBeCreated, runMigrations } = await getMigrations(config);
+  if (!toBeAdded.length && !toBeCreated.length) {
+    spinner.stop();
+    logger.success("\u{1F680} No migrations needed.");
+    process.exit(0);
+  }
+  spinner.stop();
+  logger.info(`\u{1F511} The migration will affect the following:`);
+  for (const table of [...toBeCreated, ...toBeAdded]) {
+    logger.info(
+      "->",
+      chalk.magenta(Object.keys(table.fields).join(", ")),
+      chalk.white("fields on"),
+      chalk.yellow(`${table.table}`),
+      chalk.white("table.")
+    );
+  }
+  const { migrate: migrate2 } = await prompts3({
+    type: "confirm",
+    name: "migrate",
+    message: "Are you sure you want to run these migrations?",
+    initial: false
+  });
+  if (!migrate2) {
+    logger.info("Migration cancelled.");
+    process.exit(0);
+  }
+  spinner?.start("migrating...");
+  await runMigrations();
+  spinner.stop();
+  logger.success("\u{1F680} migration was completed successfully!");
+  process.exit(0);
+});
+
+// src/cli/commands/generate.ts
+import { Command as Command2 } from "commander";
+import { z as z3 } from "zod";
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
+import ora4 from "ora";
+import prompts4 from "prompts";
+
+// src/utils/cookies.ts
+import { TimeSpan } from "oslo";
+
+// src/utils/id.ts
+import { alphabet, generateRandomString } from "oslo/crypto";
+
+// src/utils/state.ts
+import { generateState as generateStateOAuth } from "oslo/oauth2";
+import { z as z2 } from "zod";
+
+// src/adapters/kysely-adapter/index.ts
+function convertWhere(w) {
+  if (!w)
+    return {
+      and: null,
+      or: null
+    };
+  const and = w?.filter((w2) => w2.connector === "AND" || !w2.connector).reduce(
+    (acc, w2) => ({
+      ...acc,
+      [w2.field]: w2.value
+    }),
+    {}
+  );
+  const or = w?.filter((w2) => w2.connector === "OR").reduce(
+    (acc, w2) => ({
+      ...acc,
+      [w2.field]: w2.value
+    }),
+    {}
+  );
+  return {
+    and: Object.keys(and).length ? and : null,
+    or: Object.keys(or).length ? or : 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, or } = convertWhere(where);
+      let query = db.selectFrom(model).selectAll();
+      if (or) {
+        query = query.where((eb) => eb.or(or));
+      }
+      if (and) {
+        query = query.where((eb) => eb.and(and));
+      }
+      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, or } = convertWhere(where);
+      if (and) {
+        query = query.where((eb) => eb.and(and));
+      }
+      if (or) {
+        query = query.where((eb) => eb.or(or));
+      }
+      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, or } = convertWhere(where);
+      if (config?.transform) {
+        val = transformFrom(val, config.transform);
+      }
+      let query = db.updateTable(model).set(val);
+      if (and) {
+        query = query.where((eb) => eb.and(and));
+      }
+      if (or) {
+        query = query.where((eb) => eb.or(or));
+      }
+      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, or } = convertWhere(where);
+      let query = db.deleteFrom(model);
+      if (and) {
+        query = query.where((eb) => eb.and(and));
+      }
+      if (or) {
+        query = query.where((eb) => eb.or(or));
+      }
+      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`
+      };
+    }
+  };
+};
+
+// src/db/utils.ts
+async function getAdapter(options, isCli) {
+  if (!options.database) {
+    throw new BetterAuthError("Database configuration is required");
+  }
+  if ("create" in options.database) {
+    return options.database;
+  }
+  const db = await createKyselyAdapter(options, isCli);
+  if (!db) {
+    throw new BetterAuthError("Failed to initialize database adapter");
+  }
+  const tables = getAuthTables(options);
+  let schema = {};
+  for (const table of Object.values(tables)) {
+    schema[table.tableName] = table.fields;
+  }
+  return kyselyAdapter(db, {
+    transform: {
+      schema,
+      date: true,
+      boolean: getDatabaseType(options) === "sqlite"
+    }
+  });
+}
+
+// src/cli/commands/generate.ts
+import fs from "fs/promises";
+import chalk2 from "chalk";
+var generate = new Command2("generate").option(
+  "-c, --cwd <cwd>",
+  "the working directory. defaults to the current directory.",
+  process.cwd()
+).option(
+  "--config <config>",
+  "the path to the configuration file. defaults to the first configuration file found."
+).option("--out <output>", "the file to output to the generated schema").option("--y", "").action(async (opts) => {
+  const options = z3.object({
+    cwd: z3.string(),
+    config: z3.string().optional(),
+    out: z3.string().optional()
+  }).parse(opts);
+  const cwd = path3.resolve(options.cwd);
+  if (!existsSync2(cwd)) {
+    logger.error(`The directory "${cwd}" does not exist.`);
+    process.exit(1);
+  }
+  const config = await getConfig({
+    cwd,
+    configPath: options.config
+  });
+  if (!config) {
+    logger.error(
+      "No configuration file found. Add a `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag."
+    );
+    return;
+  }
+  const adapter = await getAdapter(config, true).catch((e) => {
+    logger.error(e.message);
+    process.exit(1);
+  });
+  if (!adapter.createSchema) {
+    logger.error("The adapter does not support schema generation.");
+    process.exit(1);
+  }
+  const spinner = ora4("preparing schema...").start();
+  const { code, fileName, append } = await adapter.createSchema(
+    config,
+    options.out
+  );
+  spinner.stop();
+  if (!code) {
+    logger.success("Your schema is already up to date.");
+    process.exit(0);
+  }
+  if (append) {
+    const { append: append2 } = await prompts4({
+      type: "confirm",
+      name: "append",
+      message: `The file ${fileName} already exists. Do you want to ${chalk2.yellow(
+        "append"
+      )} the schema to the file?`
+    });
+    if (append2) {
+      await fs.appendFile(path3.join(cwd, fileName), code);
+      logger.success(`\u{1F680} schema was appended successfully!`);
+      process.exit(0);
+    } else {
+      logger.error("Schema generation aborted.");
+      process.exit(1);
+    }
+  }
+  const { confirm } = await prompts4({
+    type: "confirm",
+    name: "confirm",
+    message: `Do you want to generate the schema to ${chalk2.yellow(
+      fileName
+    )}?`
+  });
+  if (!confirm) {
+    logger.error("Schema generation aborted.");
+    process.exit(1);
+  }
+  const dirExist = existsSync2(path3.dirname(path3.join(cwd, fileName)));
+  if (!dirExist) {
+    await fs.mkdir(path3.dirname(path3.join(cwd, fileName)), {
+      recursive: true
+    });
+  }
+  await fs.writeFile(options.out || path3.join(cwd, fileName), code);
+  logger.success(`\u{1F680} schema was generated successfully!`);
+  process.exit(0);
+});
+
+// src/cli/index.ts
+async function main() {
+  const program = new Command3().name("better-auth");
+  program.addCommand(migrate).addCommand(generate).version("0.0.1").description("Better Auth CLI");
+  program.parse();
+}
+main();