better-auth 1.2.6-beta.7 → 1.2.7-beta.1

package/dist/shared/better-auth.BcoSd9tC.mjs

@@ -1,10 +0,0 @@
-const TWO_FACTOR_ERROR_CODES = {
-  OTP_NOT_ENABLED: "OTP not enabled",
-  OTP_HAS_EXPIRED: "OTP has expired",
-  TOTP_NOT_ENABLED: "TOTP not enabled",
-  TWO_FACTOR_NOT_ENABLED: "Two factor isn't enabled",
-  BACKUP_CODES_NOT_ENABLED: "Backup codes aren't enabled",
-  INVALID_BACKUP_CODE: "Invalid backup code"
-};
-
-export { TWO_FACTOR_ERROR_CODES as T };

package/dist/shared/better-auth.BnRFp-t0.mjs

@@ -1,405 +0,0 @@
-import { Kysely, SqliteDialect, MysqlDialect, PostgresDialect, MssqlDialect } from 'kysely';
-import './better-auth.CepcSj5H.mjs';
-import './better-auth.8zoxzg-F.mjs';
-import { g as generateId } from './better-auth.BUPPRXfK.mjs';
-import 'zod';
-import 'better-call';
-import '@better-auth/utils/hash';
-import '@noble/ciphers/chacha';
-import '@noble/ciphers/utils';
-import '@noble/ciphers/webcrypto';
-import '@better-auth/utils/base64';
-import 'jose';
-import '@noble/hashes/scrypt';
-import '@better-auth/utils';
-import '@better-auth/utils/hex';
-import '@noble/hashes/utils';
-import './better-auth.B4Qoxdgc.mjs';
-import './better-auth.DH3YjMQH.mjs';
-import { g as getAuthTables } from './better-auth.DORkW_Ge.mjs';
-import { w as withApplyDefault } from './better-auth.0TC26uRi.mjs';
-
-function getDatabaseType(db) {
-  if (!db) {
-    return null;
-  }
-  if ("dialect" in db) {
-    return getDatabaseType(db.dialect);
-  }
-  if ("createDriver" in db) {
-    if (db instanceof SqliteDialect) {
-      return "sqlite";
-    }
-    if (db instanceof MysqlDialect) {
-      return "mysql";
-    }
-    if (db instanceof PostgresDialect) {
-      return "postgres";
-    }
-    if (db instanceof MssqlDialect) {
-      return "mssql";
-    }
-  }
-  if ("aggregate" in db) {
-    return "sqlite";
-  }
-  if ("getConnection" in db) {
-    return "mysql";
-  }
-  if ("connect" in db) {
-    return "postgres";
-  }
-  return null;
-}
-const createKyselyAdapter = async (config) => {
-  const db = config.database;
-  if (!db) {
-    return {
-      kysely: null,
-      databaseType: null
-    };
-  }
-  if ("db" in db) {
-    return {
-      kysely: db.db,
-      databaseType: db.type
-    };
-  }
-  if ("dialect" in db) {
-    return {
-      kysely: new Kysely({ dialect: db.dialect }),
-      databaseType: db.type
-    };
-  }
-  let dialect = void 0;
-  const databaseType = getDatabaseType(db);
-  if ("createDriver" in db) {
-    dialect = db;
-  }
-  if ("aggregate" in db) {
-    dialect = new SqliteDialect({
-      database: db
-    });
-  }
-  if ("getConnection" in db) {
-    dialect = new MysqlDialect(db);
-  }
-  if ("connect" in db) {
-    dialect = new PostgresDialect({
-      pool: db
-    });
-  }
-  return {
-    kysely: dialect ? new Kysely({ dialect }) : null,
-    databaseType
-  };
-};
-
-const createTransform = (db, options, config) => {
-  const schema = getAuthTables(options);
-  function getField(model, field) {
-    if (field === "id") {
-      return field;
-    }
-    const f = schema[model].fields[field];
-    if (!f) {
-      console.log("Field not found", model, field);
-    }
-    return f.fieldName || field;
-  }
-  function transformValueToDB(value, model, field) {
-    if (field === "id") {
-      return value;
-    }
-    const { type = "sqlite" } = config || {};
-    const f = schema[model].fields[field];
-    if (f.type === "boolean" && (type === "sqlite" || type === "mssql") && value !== null && value !== void 0) {
-      return value ? 1 : 0;
-    }
-    if (f.type === "date" && value && value instanceof Date) {
-      return type === "sqlite" ? value.toISOString() : value;
-    }
-    return value;
-  }
-  function transformValueFromDB(value, model, field) {
-    const { type = "sqlite" } = config || {};
-    const f = schema[model].fields[field];
-    if (f.type === "boolean" && (type === "sqlite" || type === "mssql") && value !== null) {
-      return value === 1;
-    }
-    if (f.type === "date" && value) {
-      return new Date(value);
-    }
-    return value;
-  }
-  function getModelName(model) {
-    return schema[model].modelName;
-  }
-  const useDatabaseGeneratedId = options?.advanced?.generateId === false;
-  return {
-    transformInput(data, model, action) {
-      const transformedData = useDatabaseGeneratedId || action === "update" ? {} : {
-        id: options.advanced?.generateId ? options.advanced.generateId({
-          model
-        }) : data.id || generateId()
-      };
-      const fields = schema[model].fields;
-      for (const field in fields) {
-        const value = data[field];
-        transformedData[fields[field].fieldName || field] = withApplyDefault(
-          transformValueToDB(value, model, field),
-          fields[field],
-          action
-        );
-      }
-      return transformedData;
-    },
-    transformOutput(data, model, select = []) {
-      if (!data) return null;
-      const transformedData = 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] = transformValueFromDB(
-            data[field.fieldName || key],
-            model,
-            key
-          );
-        }
-      }
-      return transformedData;
-    },
-    convertWhereClause(model, w) {
-      if (!w)
-        return {
-          and: null,
-          or: null
-        };
-      const conditions = {
-        and: [],
-        or: []
-      };
-      w.forEach((condition) => {
-        let {
-          field: _field,
-          value,
-          operator = "=",
-          connector = "AND"
-        } = condition;
-        const field = getField(model, _field);
-        value = transformValueToDB(value, model, _field);
-        const expr = (eb) => {
-          if (operator.toLowerCase() === "in") {
-            return eb(field, "in", Array.isArray(value) ? value : [value]);
-          }
-          if (operator === "contains") {
-            return eb(field, "like", `%${value}%`);
-          }
-          if (operator === "starts_with") {
-            return eb(field, "like", `${value}%`);
-          }
-          if (operator === "ends_with") {
-            return eb(field, "like", `%${value}`);
-          }
-          if (operator === "eq") {
-            return eb(field, "=", value);
-          }
-          if (operator === "ne") {
-            return eb(field, "<>", value);
-          }
-          if (operator === "gt") {
-            return eb(field, ">", value);
-          }
-          if (operator === "gte") {
-            return eb(field, ">=", value);
-          }
-          if (operator === "lt") {
-            return eb(field, "<", value);
-          }
-          if (operator === "lte") {
-            return eb(field, "<=", value);
-          }
-          return eb(field, operator, value);
-        };
-        if (connector === "OR") {
-          conditions.or.push(expr);
-        } else {
-          conditions.and.push(expr);
-        }
-      });
-      return {
-        and: conditions.and.length ? conditions.and : null,
-        or: conditions.or.length ? conditions.or : null
-      };
-    },
-    async withReturning(values, builder, model, where) {
-      let res;
-      if (config?.type === "mysql") {
-        await builder.execute();
-        const field = values.id ? "id" : where[0].field ? where[0].field : "id";
-        const value = values[field] || where[0].value;
-        res = await db.selectFrom(getModelName(model)).selectAll().where(getField(model, field), "=", value).executeTakeFirst();
-        return res;
-      }
-      if (config?.type === "mssql") {
-        res = await builder.outputAll("inserted").executeTakeFirst();
-        return res;
-      }
-      res = await builder.returningAll().executeTakeFirst();
-      return res;
-    },
-    getModelName,
-    getField
-  };
-};
-const kyselyAdapter = (db, config) => (opts) => {
-  const {
-    transformInput,
-    withReturning,
-    transformOutput,
-    convertWhereClause,
-    getModelName,
-    getField
-  } = createTransform(db, opts, config);
-  return {
-    id: "kysely",
-    async create(data) {
-      const { model, data: values, select } = data;
-      const transformed = transformInput(values, model, "create");
-      const builder = db.insertInto(getModelName(model)).values(transformed);
-      return transformOutput(
-        await withReturning(transformed, builder, model, []),
-        model,
-        select
-      );
-    },
-    async findOne(data) {
-      const { model, where, select } = data;
-      const { and, or } = convertWhereClause(model, where);
-      let query = db.selectFrom(getModelName(model)).selectAll();
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      const res = await query.executeTakeFirst();
-      if (!res) return null;
-      return transformOutput(res, model, select);
-    },
-    async findMany(data) {
-      const { model, where, limit, offset, sortBy } = data;
-      const { and, or } = convertWhereClause(model, where);
-      let query = db.selectFrom(getModelName(model));
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      if (config?.type === "mssql") {
-        if (!offset) {
-          query = query.top(limit || 100);
-        }
-      } else {
-        query = query.limit(limit || 100);
-      }
-      if (sortBy) {
-        query = query.orderBy(
-          getField(model, sortBy.field),
-          sortBy.direction
-        );
-      }
-      if (offset) {
-        if (config?.type === "mssql") {
-          if (!sortBy) {
-            query = query.orderBy(getField(model, "id"));
-          }
-          query = query.offset(offset).fetch(limit || 100);
-        } else {
-          query = query.offset(offset);
-        }
-      }
-      const res = await query.selectAll().execute();
-      if (!res) return [];
-      return res.map((r) => transformOutput(r, model));
-    },
-    async update(data) {
-      const { model, where, update: values } = data;
-      const { and, or } = convertWhereClause(model, where);
-      const transformedData = transformInput(values, model, "update");
-      let query = db.updateTable(getModelName(model)).set(transformedData);
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      const res = await transformOutput(
-        await withReturning(transformedData, query, model, where),
-        model
-      );
-      return res;
-    },
-    async updateMany(data) {
-      const { model, where, update: values } = data;
-      const { and, or } = convertWhereClause(model, where);
-      const transformedData = transformInput(values, model, "update");
-      let query = db.updateTable(getModelName(model)).set(transformedData);
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      const res = await query.execute();
-      return res.length;
-    },
-    async count(data) {
-      const { model, where } = data;
-      const { and, or } = convertWhereClause(model, where);
-      let query = db.selectFrom(getModelName(model)).select(db.fn.count("id").as("count"));
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      const res = await query.execute();
-      return res[0].count;
-    },
-    async delete(data) {
-      const { model, where } = data;
-      const { and, or } = convertWhereClause(model, where);
-      let query = db.deleteFrom(getModelName(model));
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      await query.execute();
-    },
-    async deleteMany(data) {
-      const { model, where } = data;
-      const { and, or } = convertWhereClause(model, where);
-      let query = db.deleteFrom(getModelName(model));
-      if (and) {
-        query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
-      }
-      if (or) {
-        query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
-      }
-      return (await query.execute()).length;
-    },
-    options: config
-  };
-};
-
-export { createKyselyAdapter as c, kyselyAdapter as k };

package/dist/shared/better-auth.C1-vpKly.cjs

@@ -1,12 +0,0 @@
-'use strict';
-
-const TWO_FACTOR_ERROR_CODES = {
-  OTP_NOT_ENABLED: "OTP not enabled",
-  OTP_HAS_EXPIRED: "OTP has expired",
-  TOTP_NOT_ENABLED: "TOTP not enabled",
-  TWO_FACTOR_NOT_ENABLED: "Two factor isn't enabled",
-  BACKUP_CODES_NOT_ENABLED: "Backup codes aren't enabled",
-  INVALID_BACKUP_CODE: "Invalid backup code"
-};
-
-exports.TWO_FACTOR_ERROR_CODES = TWO_FACTOR_ERROR_CODES;

package/dist/shared/better-auth.ClTSOgiD.mjs

@@ -1,140 +0,0 @@
-import { APIError } from 'better-call';
-import { c as createAuthMiddleware, g as getSessionFromCtx } from './better-auth.D4jH-sJA.mjs';
-import { setSessionCookie } from '../cookies/index.mjs';
-import { z } from 'zod';
-import './better-auth.CepcSj5H.mjs';
-import './better-auth.8zoxzg-F.mjs';
-import './better-auth.DH3YjMQH.mjs';
-import 'defu';
-import { createHMAC } from '@better-auth/utils/hmac';
-
-const TWO_FACTOR_COOKIE_NAME = "two_factor";
-const TRUST_DEVICE_COOKIE_NAME = "trust_device";
-
-const verifyTwoFactorMiddleware = createAuthMiddleware(
-  {
-    body: z.object({
-      /**
-       * if true, the device will be trusted
-       * for 30 days. It'll be refreshed on
-       * every sign in request within this time.
-       */
-      trustDevice: z.boolean().optional()
-    })
-  },
-  async (ctx) => {
-    const session = await getSessionFromCtx(ctx);
-    if (!session) {
-      const cookieName = ctx.context.createAuthCookie(TWO_FACTOR_COOKIE_NAME);
-      const userId = await ctx.getSignedCookie(
-        cookieName.name,
-        ctx.context.secret
-      );
-      if (!userId) {
-        throw new APIError("UNAUTHORIZED", {
-          message: "invalid two factor cookie"
-        });
-      }
-      const user = await ctx.context.internalAdapter.findUserById(
-        userId
-      );
-      if (!user) {
-        throw new APIError("UNAUTHORIZED", {
-          message: "invalid two factor cookie"
-        });
-      }
-      const dontRememberMe = await ctx.getSignedCookie(
-        ctx.context.authCookies.dontRememberToken.name,
-        ctx.context.secret
-      );
-      const session2 = await ctx.context.internalAdapter.createSession(
-        userId,
-        ctx.request,
-        !!dontRememberMe
-      );
-      if (!session2) {
-        throw new APIError("INTERNAL_SERVER_ERROR", {
-          message: "failed to create session"
-        });
-      }
-      return {
-        valid: async (ctx2) => {
-          await setSessionCookie(ctx2, {
-            session: session2,
-            user
-          });
-          if (ctx2.body.trustDevice) {
-            const trustDeviceCookie = ctx2.context.createAuthCookie(
-              TRUST_DEVICE_COOKIE_NAME,
-              {
-                maxAge: 30 * 24 * 60 * 60
-                // 30 days, it'll be refreshed on sign in requests
-              }
-            );
-            const token = await createHMAC("SHA-256", "base64urlnopad").sign(
-              ctx2.context.secret,
-              `${user.id}!${session2.token}`
-            );
-            await ctx2.setSignedCookie(
-              trustDeviceCookie.name,
-              `${token}!${session2.token}`,
-              ctx2.context.secret,
-              trustDeviceCookie.attributes
-            );
-            ctx2.setCookie(ctx2.context.authCookies.dontRememberToken.name, "", {
-              maxAge: 0
-            });
-            ctx2.setCookie(cookieName.name, "", {
-              maxAge: 0
-            });
-          }
-          return ctx2.json({
-            token: session2.token,
-            user: {
-              id: user.id,
-              email: user.email,
-              emailVerified: user.emailVerified,
-              name: user.name,
-              image: user.image,
-              createdAt: user.createdAt,
-              updatedAt: user.updatedAt
-            }
-          });
-        },
-        invalid: async () => {
-          throw new APIError("UNAUTHORIZED", {
-            message: "invalid two factor authentication"
-          });
-        },
-        session: {
-          session: session2,
-          user
-        }
-      };
-    }
-    return {
-      valid: async (ctx2) => {
-        return ctx2.json({
-          token: session.session.token,
-          user: {
-            id: session.user.id,
-            email: session.user.email,
-            emailVerified: session.user.emailVerified,
-            name: session.user.name,
-            image: session.user.image,
-            createdAt: session.user.createdAt,
-            updatedAt: session.user.updatedAt
-          }
-        });
-      },
-      invalid: async () => {
-        throw new APIError("UNAUTHORIZED", {
-          message: "invalid two factor authentication"
-        });
-      },
-      session
-    };
-  }
-);
-
-export { TRUST_DEVICE_COOKIE_NAME as T, TWO_FACTOR_COOKIE_NAME as a, verifyTwoFactorMiddleware as v };