better-auth 1.2.0-beta.8 → 1.2.0

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

@@ -0,0 +1,67 @@
+import type { BetterAuthOptions, Where } from "../../types";
+export interface DB {
+    [key: string]: any;
+}
+export interface DrizzleAdapterConfig {
+    /**
+     * The schema object that defines the tables and fields
+     */
+    schema?: Record<string, any>;
+    /**
+     * The database provider
+     */
+    provider: "pg" | "mysql" | "sqlite";
+    /**
+     * If the table names in the schema are plural
+     * set this to true. For example, if the schema
+     * has an object with a key "users" instead of "user"
+     */
+    usePlural?: boolean;
+}
+export declare const drizzleAdapter: (db: DB, config: DrizzleAdapterConfig) => (options: BetterAuthOptions) => {
+    id: string;
+    create<T extends Record<string, any>, R = T>(data: {
+        model: string;
+        data: T;
+        select?: string[];
+    }): Promise<any>;
+    findOne<T>(data: {
+        model: string;
+        where: Where[];
+        select?: string[];
+    }): Promise<any>;
+    findMany<T>(data: {
+        model: string;
+        where?: Where[];
+        limit?: number;
+        sortBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        };
+        offset?: number;
+    }): Promise<any[]>;
+    count(data: {
+        model: string;
+        where?: Where[];
+    }): Promise<any>;
+    update<T>(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }): Promise<any>;
+    updateMany(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }): Promise<any>;
+    delete<T>(data: {
+        model: string;
+        where: Where[];
+    }): Promise<void>;
+    deleteMany(data: {
+        model: string;
+        where: Where[];
+    }): Promise<any>;
+    options: DrizzleAdapterConfig;
+};
+//# sourceMappingURL=drizzle-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/drizzle-adapter/drizzle-adapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAW,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIrE,MAAM,WAAW,EAAE;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACnB;AAiND,MAAM,WAAW,oBAAoB;IACpC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B;;OAEG;IACH,QAAQ,EAAE,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAqBD,eAAO,MAAM,cAAc,GACzB,IAAI,EAAE,EAAE,QAAQ,oBAAoB,MAAM,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GpE,CAAC"}

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

@@ -0,0 +1,285 @@
+'use strict';
+
+const drizzleOrm = require('drizzle-orm');
+require('../../shared/better-auth.CHyZMcYK.cjs');
+require('../../shared/better-auth.DiSjtgs9.cjs');
+const id = require('../../shared/better-auth.Bg6iw3ig.cjs');
+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');
+const getTables = require('../../shared/better-auth.BEphVDyL.cjs');
+const index = require('../../shared/better-auth.ANpbi45u.cjs');
+require('kysely');
+const utils = require('../../shared/better-auth.CUdxApHl.cjs');
+require('@better-auth/utils/random');
+
+const createTransform = (db, config, options) => {
+  const schema = getTables.getAuthTables(options);
+  function getField(model, field) {
+    if (field === "id") {
+      return field;
+    }
+    const f = schema[model].fields[field];
+    return f.fieldName || field;
+  }
+  function getSchema(modelName) {
+    const schema2 = config.schema || db._.fullSchema;
+    if (!schema2) {
+      throw new index.BetterAuthError(
+        "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
+      );
+    }
+    const model = getModelName(modelName);
+    const schemaModel = schema2[model];
+    if (!schemaModel) {
+      throw new index.BetterAuthError(
+        `[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`
+      );
+    }
+    return schemaModel;
+  }
+  const getModelName = (model) => {
+    return schema[model].modelName !== model ? schema[model].modelName : config.usePlural ? `${model}s` : model;
+  };
+  function convertWhereClause(where, model) {
+    const schemaModel = getSchema(model);
+    if (!where) return [];
+    if (where.length === 1) {
+      const w = where[0];
+      if (!w) {
+        return [];
+      }
+      const field = getField(model, w.field);
+      if (!schemaModel[field]) {
+        throw new index.BetterAuthError(
+          `The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`
+        );
+      }
+      if (w.operator === "in") {
+        if (!Array.isArray(w.value)) {
+          throw new index.BetterAuthError(
+            `The value for the field "${w.field}" must be an array when using the "in" operator.`
+          );
+        }
+        return [drizzleOrm.inArray(schemaModel[field], w.value)];
+      }
+      if (w.operator === "contains") {
+        return [drizzleOrm.like(schemaModel[field], `%${w.value}%`)];
+      }
+      if (w.operator === "starts_with") {
+        return [drizzleOrm.like(schemaModel[field], `${w.value}%`)];
+      }
+      if (w.operator === "ends_with") {
+        return [drizzleOrm.like(schemaModel[field], `%${w.value}`)];
+      }
+      return [drizzleOrm.eq(schemaModel[field], w.value)];
+    }
+    const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+    const orGroup = where.filter((w) => w.connector === "OR");
+    const andClause = drizzleOrm.and(
+      ...andGroup.map((w) => {
+        const field = getField(model, w.field);
+        if (w.operator === "in") {
+          if (!Array.isArray(w.value)) {
+            throw new index.BetterAuthError(
+              `The value for the field "${w.field}" must be an array when using the "in" operator.`
+            );
+          }
+          return drizzleOrm.inArray(schemaModel[field], w.value);
+        }
+        return drizzleOrm.eq(schemaModel[field], w.value);
+      })
+    );
+    const orClause = drizzleOrm.or(
+      ...orGroup.map((w) => {
+        const field = getField(model, w.field);
+        return drizzleOrm.eq(schemaModel[field], w.value);
+      })
+    );
+    const clause = [];
+    if (andGroup.length) clause.push(andClause);
+    if (orGroup.length) clause.push(orClause);
+    return clause;
+  }
+  const useDatabaseGeneratedId = options?.advanced?.generateId === false;
+  return {
+    getSchema,
+    transformInput(data, model, action) {
+      const transformedData = useDatabaseGeneratedId || action === "update" ? {} : {
+        id: options.advanced?.generateId ? options.advanced.generateId({
+          model
+        }) : data.id || id.generateId()
+      };
+      const fields = schema[model].fields;
+      for (const field in fields) {
+        const value = data[field];
+        if (value === void 0 && !fields[field].defaultValue) {
+          continue;
+        }
+        transformedData[fields[field].fieldName || field] = utils.withApplyDefault(
+          value,
+          fields[field],
+          action
+        );
+      }
+      return transformedData;
+    },
+    transformOutput(data, model, select = []) {
+      if (!data) return null;
+      const transformedData = data.id || data._id ? select.length === 0 || select.includes("id") ? {
+        id: data.id
+      } : {} : {};
+      const tableSchema = schema[model].fields;
+      for (const key in tableSchema) {
+        if (select.length && !select.includes(key)) {
+          continue;
+        }
+        const field = tableSchema[key];
+        if (field) {
+          transformedData[key] = data[field.fieldName || key];
+        }
+      }
+      return transformedData;
+    },
+    convertWhereClause,
+    withReturning: async (model, builder, data, where) => {
+      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) {
+        const tId = builderVal[0]?.id.value;
+        const res = await db.select().from(schemaModel).where(drizzleOrm.eq(schemaModel.id, tId));
+        return res[0];
+      } else if (data.id) {
+        const res = await db.select().from(schemaModel).where(drizzleOrm.eq(schemaModel.id, data.id));
+        return res[0];
+      }
+    },
+    getField,
+    getModelName
+  };
+};
+function checkMissingFields(schema, model, values) {
+  if (!schema) {
+    throw new index.BetterAuthError(
+      "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
+    );
+  }
+  for (const key in values) {
+    if (!schema[key]) {
+      throw new index.BetterAuthError(
+        `The field "${key}" does not exist in the "${model}" schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli generate".`
+      );
+    }
+  }
+}
+const drizzleAdapter = (db, config) => (options) => {
+  const {
+    transformInput,
+    transformOutput,
+    convertWhereClause,
+    getSchema,
+    withReturning,
+    getField,
+    getModelName
+  } = createTransform(db, config, options);
+  return {
+    id: "drizzle",
+    async create(data) {
+      const { model, data: values } = data;
+      const transformed = transformInput(values, model, "create");
+      const schemaModel = getSchema(model);
+      checkMissingFields(schemaModel, getModelName(model), transformed);
+      const builder = db.insert(schemaModel).values(transformed);
+      const returned = await withReturning(model, builder, transformed);
+      return transformOutput(returned, model);
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const schemaModel = getSchema(model);
+      const clause = convertWhereClause(where, model);
+      const res = await db.select().from(schemaModel).where(...clause);
+      if (!res.length) return null;
+      return transformOutput(res[0], model, select);
+    },
+    async findMany(data) {
+      const { model, where, sortBy, limit, offset } = data;
+      const schemaModel = getSchema(model);
+      const clause = where ? convertWhereClause(where, model) : [];
+      const sortFn = sortBy?.direction === "desc" ? drizzleOrm.desc : drizzleOrm.asc;
+      const builder = db.select().from(schemaModel).limit(limit || 100).offset(offset || 0);
+      if (sortBy?.field) {
+        builder.orderBy(sortFn(schemaModel[getField(model, sortBy?.field)]));
+      }
+      const res = await builder.where(...clause);
+      return res.map((r) => transformOutput(r, model));
+    },
+    async count(data) {
+      const { model, where } = data;
+      const schemaModel = getSchema(model);
+      const clause = where ? convertWhereClause(where, model) : [];
+      const res = await db.select({ count: drizzleOrm.count() }).from(schemaModel).where(...clause);
+      return res.count;
+    },
+    async update(data) {
+      const { model, where, update: values } = data;
+      const schemaModel = getSchema(model);
+      const clause = convertWhereClause(where, model);
+      const transformed = transformInput(values, model, "update");
+      const builder = db.update(schemaModel).set(transformed).where(...clause);
+      const returned = await withReturning(
+        model,
+        builder,
+        transformed,
+        where
+      );
+      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
+  };
+};
+
+exports.drizzleAdapter = drizzleAdapter;

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

@@ -0,0 +1,2 @@
+export * from "./drizzle-adapter";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/drizzle-adapter/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

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

@@ -0,0 +1,283 @@
+import { count, desc, asc, eq, inArray, like, and, or } from 'drizzle-orm';
+import '../../shared/better-auth.C24Bzw4w.mjs';
+import '../../shared/better-auth.8zoxzg-F.mjs';
+import { g as generateId } from '../../shared/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 '../../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';
+
+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 field = getField(model, 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)];
+      }
+      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}`)];
+      }
+      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);
+        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 = 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;
+        }
+        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;
+        }
+        const field = tableSchema[key];
+        if (field) {
+          transformedData[key] = data[field.fieldName || key];
+        }
+      }
+      return transformedData;
+    },
+    convertWhereClause,
+    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) {
+        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".`
+      );
+    }
+  }
+}
+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/kysely-adapter/dialect.d.ts

@@ -0,0 +1,8 @@
+import { Kysely } from "kysely";
+import type { BetterAuthOptions } from "../../types";
+import type { KyselyDatabaseType } from "./types";
+export declare const createKyselyAdapter: (config: BetterAuthOptions) => Promise<{
+    kysely: Kysely<any> | null;
+    databaseType: KyselyDatabaseType | null;
+}>;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/adapters/kysely-adapter/dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../../src/adapters/kysely-adapter/dialect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,QAAQ,CAAC;AAO9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAuClD,eAAO,MAAM,mBAAmB,GAAU,QAAQ,iBAAiB;;;EAqDlE,CAAC"}

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

@@ -0,0 +1,29 @@
+'use strict';
+
+const kyselyAdapter = require('../../shared/better-auth.lwzD09PV.cjs');
+require('kysely');
+require('../../shared/better-auth.CHyZMcYK.cjs');
+require('zod');
+require('better-call');
+require('../../shared/better-auth.DiSjtgs9.cjs');
+require('../../shared/better-auth.Bg6iw3ig.cjs');
+require('@better-auth/utils/random');
+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');
+require('../../shared/better-auth.BEphVDyL.cjs');
+require('../../shared/better-auth.CUdxApHl.cjs');
+
+
+
+exports.createKyselyAdapter = kyselyAdapter.createKyselyAdapter;
+exports.kyselyAdapter = kyselyAdapter.kyselyAdapter;

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

@@ -0,0 +1,4 @@
+export * from "./dialect";
+export * from "./types";
+export * from "./kysely-adapter";
+//# sourceMappingURL=index.d.ts.map