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

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

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

package/dist/adapters/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const index = require('../shared/better-auth.DjryM8pE.cjs');
+require('../shared/better-auth.D3mtHEZg.cjs');
+require('../shared/better-auth.CUdxApHl.cjs');
+require('../shared/better-auth.BEphVDyL.cjs');
+require('../shared/better-auth.Bg6iw3ig.cjs');
+require('@better-auth/utils/random');
+require('zod');
+require('better-call');
+require('@better-auth/utils/hash');
+require('@noble/ciphers/chacha');
+require('@noble/ciphers/utils');
+require('@noble/ciphers/webcrypto');
+require('@better-auth/utils/base64');
+require('jose');
+require('@noble/hashes/scrypt');
+require('@better-auth/utils');
+require('@better-auth/utils/hex');
+require('@noble/hashes/utils');
+require('../shared/better-auth.CYeOI8C-.cjs');
+require('../shared/better-auth.GpOOav9x.cjs');
+
+
+
+exports.createAdapter = index.createAdapter;

package/dist/adapters/index.d.cts

@@ -0,0 +1,17 @@
+import { f as BetterAuthOptions, g as Adapter } from '../shared/better-auth.BcU1Kjyq.cjs';
+import { a as AdapterConfig, C as CreateCustomAdapter } from '../shared/better-auth.eVy4DZvP.cjs';
+export { A as AdapterDebugLogs, d as AdapterTestDebugLogs, c as CleanedWhere, b as CustomAdapter } from '../shared/better-auth.eVy4DZvP.cjs';
+import '../shared/better-auth.CYegVoq1.cjs';
+import 'zod';
+import '../shared/better-auth.DTiSPWEk.cjs';
+import 'jose';
+import 'kysely';
+import 'better-call';
+import 'better-sqlite3';
+
+declare const createAdapter: ({ adapter, config: cfg, }: {
+    config: AdapterConfig;
+    adapter: CreateCustomAdapter;
+}) => (options: BetterAuthOptions) => Adapter;
+
+export { AdapterConfig, CreateCustomAdapter, createAdapter };

package/dist/adapters/index.d.mts

@@ -0,0 +1,17 @@
+import { f as BetterAuthOptions, g as Adapter } from '../shared/better-auth.DQ7OSJbI.mjs';
+import { a as AdapterConfig, C as CreateCustomAdapter } from '../shared/better-auth.SPmq4a4z.mjs';
+export { A as AdapterDebugLogs, d as AdapterTestDebugLogs, c as CleanedWhere, b as CustomAdapter } from '../shared/better-auth.SPmq4a4z.mjs';
+import '../shared/better-auth.CYegVoq1.mjs';
+import 'zod';
+import '../shared/better-auth.B88xucNq.mjs';
+import 'jose';
+import 'kysely';
+import 'better-call';
+import 'better-sqlite3';
+
+declare const createAdapter: ({ adapter, config: cfg, }: {
+    config: AdapterConfig;
+    adapter: CreateCustomAdapter;
+}) => (options: BetterAuthOptions) => Adapter;
+
+export { AdapterConfig, CreateCustomAdapter, createAdapter };

package/dist/adapters/index.d.ts

@@ -0,0 +1,17 @@
+import { f as BetterAuthOptions, g as Adapter } from '../shared/better-auth.CA2hFK4N.js';
+import { a as AdapterConfig, C as CreateCustomAdapter } from '../shared/better-auth.cp2rC2iM.js';
+export { A as AdapterDebugLogs, d as AdapterTestDebugLogs, c as CleanedWhere, b as CustomAdapter } from '../shared/better-auth.cp2rC2iM.js';
+import '../shared/better-auth.CYegVoq1.js';
+import 'zod';
+import '../shared/better-auth.DNTAFSt1.js';
+import 'jose';
+import 'kysely';
+import 'better-call';
+import 'better-sqlite3';
+
+declare const createAdapter: ({ adapter, config: cfg, }: {
+    config: AdapterConfig;
+    adapter: CreateCustomAdapter;
+}) => (options: BetterAuthOptions) => Adapter;
+
+export { AdapterConfig, CreateCustomAdapter, createAdapter };

package/dist/adapters/index.mjs

@@ -0,0 +1,20 @@
+export { c as createAdapter } from '../shared/better-auth.rSYJCd3o.mjs';
+import '../shared/better-auth.tB5eU6EY.mjs';
+import '../shared/better-auth.0TC26uRi.mjs';
+import '../shared/better-auth.DORkW_Ge.mjs';
+import '../shared/better-auth.BUPPRXfK.mjs';
+import '@better-auth/utils/random';
+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 '../shared/better-auth.B4Qoxdgc.mjs';
+import '../shared/better-auth.Cqykj82J.mjs';

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

@@ -1,13 +1,15 @@
 'use strict';
 
-const kyselyAdapter = require('../../shared/better-auth.DqLjzBlO.cjs');
+const kyselyAdapter = require('../../shared/better-auth.CVCo5Z2T.cjs');
 require('kysely');
-require('../../shared/better-auth.C5H9XEzZ.cjs');
-require('zod');
-require('better-call');
-require('../../shared/better-auth.DiSjtgs9.cjs');
+require('../../shared/better-auth.DjryM8pE.cjs');
+require('../../shared/better-auth.D3mtHEZg.cjs');
+require('../../shared/better-auth.CUdxApHl.cjs');
+require('../../shared/better-auth.BEphVDyL.cjs');
 require('../../shared/better-auth.Bg6iw3ig.cjs');
 require('@better-auth/utils/random');
+require('zod');
+require('better-call');
 require('@better-auth/utils/hash');
 require('@noble/ciphers/chacha');
 require('@noble/ciphers/utils');
@@ -20,8 +22,6 @@ require('@better-auth/utils/hex');
 require('@noble/hashes/utils');
 require('../../shared/better-auth.CYeOI8C-.cjs');
 require('../../shared/better-auth.GpOOav9x.cjs');
-require('../../shared/better-auth.BEphVDyL.cjs');
-require('../../shared/better-auth.CUdxApHl.cjs');