better-auth 0.2.4 → 0.2.5-beta.2

package/dist/adapters/drizzle.d.ts

@@ -0,0 +1,18 @@
+import { A as Adapter } from '../index-CcdDoX76.js';
+import 'kysely';
+import '../index-CE92ti2Z.js';
+import 'arctic';
+import 'zod';
+import '../helper-C1ihmerM.js';
+import 'better-call';
+
+interface DrizzleAdapterOptions {
+    schema?: Record<string, any>;
+    provider: "pg" | "mysql" | "sqlite";
+}
+interface DB {
+    [key: string]: any;
+}
+declare const drizzleAdapter: (db: DB, options: DrizzleAdapterOptions) => Adapter;
+
+export { type DrizzleAdapterOptions, drizzleAdapter };

package/dist/adapters/drizzle.js

@@ -0,0 +1,337 @@
+// src/adapters/drizzle-adapter/index.ts
+import { and, eq, or } from "drizzle-orm";
+import * as prettier from "prettier";
+
+// 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: options.user?.modelName || "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: options.user?.modelName || "user",
+            field: "id",
+            onDelete: "cascade"
+          },
+          required: true
+        },
+        accessToken: {
+          type: "string",
+          required: false
+        },
+        refreshToken: {
+          type: "string",
+          required: false
+        },
+        idToken: {
+          type: "string",
+          required: false
+        },
+        expiresAt: {
+          type: "date",
+          required: false
+        },
+        password: {
+          type: "string",
+          required: false
+        },
+        ...account?.fields
+      },
+      order: 2
+    },
+    ...pluginTables,
+    ...shouldAddRateLimitTable ? rateLimitTable : {}
+  };
+};
+
+// src/adapters/drizzle-adapter/index.ts
+import { existsSync } from "fs";
+import fs from "fs/promises";
+
+// 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 = "";
+  }
+};
+
+// src/adapters/drizzle-adapter/index.ts
+function getSchema(modelName, schema) {
+  const key = Object.keys(schema).find((key2) => {
+    const modelName2 = schema[key2].name;
+    return modelName2 === modelName2;
+  });
+  if (!key) {
+    throw new Error("Model not found");
+  }
+  return schema[key];
+}
+function whereConvertor(where, schemaModel) {
+  if (!where) return [];
+  if (where.length === 1) {
+    const w = where[0];
+    if (!w) {
+      return [];
+    }
+    return [eq(schemaModel[w.field], w.value)];
+  }
+  const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+  const orGroup = where.filter((w) => w.connector === "OR");
+  const andClause = and(
+    ...andGroup.map((w) => {
+      return eq(schemaModel[w.field], w.value);
+    })
+  );
+  const orClause = or(
+    ...orGroup.map((w) => {
+      return eq(schemaModel[w.field], w.value);
+    })
+  );
+  const clause = [];
+  if (andGroup.length) clause.push(andClause);
+  if (orGroup.length) clause.push(orClause);
+  return clause;
+}
+var drizzleAdapter = (db, options) => {
+  const schema = options?.schema || db._.schema;
+  if (!schema) {
+    throw new BetterAuthError(
+      "Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object."
+    );
+  }
+  const databaseType = options?.provider;
+  return {
+    id: "drizzle",
+    async create(data) {
+      const { model, data: val } = data;
+      const schemaModel = getSchema(model, schema);
+      const res = await db.insert(schemaModel).values(val).returning();
+      return res[0];
+    },
+    async findOne(data) {
+      const { model, where, select: included } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = whereConvertor(where, schemaModel);
+      let res = null;
+      if (!!included?.length) {
+        res = await db.select(
+          ...included.map((include) => {
+            return {
+              [include]: schemaModel[include]
+            };
+          })
+        ).from(schemaModel).where(...wheres);
+      } else {
+        res = await db.select().from(schemaModel).where(...wheres);
+      }
+      if (!!res.length) return res[0];
+      else return null;
+    },
+    async findMany(data) {
+      const { model, where } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = where ? whereConvertor(where, schemaModel) : [];
+      return await db.select().from(schemaModel).findMany(...wheres);
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = whereConvertor(where, schemaModel);
+      const res = await db.update(schemaModel).set(update).where(...wheres).returning();
+      return res[0];
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const schemaModel = getSchema(model, schema);
+      const wheres = whereConvertor(where, schemaModel);
+      const res = await db.delete(schemaModel).where(...wheres);
+      return res[0];
+    },
+    async createSchema(options2, file) {
+      const tables = getAuthTables(options2);
+      const filePath = file || "./schema.ts";
+      const timestampAndBoolean = databaseType !== "sqlite" ? "timestamp, boolean" : "";
+      const int = databaseType === "mysql" ? "int" : "integer";
+      let code = `import { ${databaseType}Table, text, ${int}, ${timestampAndBoolean} } from "drizzle-orm/${databaseType}-core";
+			`;
+      const fileExist = existsSync(filePath);
+      let fileContent = await fs.readFile(filePath, "utf-8");
+      for (const table in tables) {
+        let getType2 = function(name, type) {
+          if (type === "string") {
+            return `text('${name}')`;
+          }
+          if (type === "number") {
+            return `${int}('${name}')`;
+          }
+          if (type === "boolean") {
+            if (databaseType === "sqlite") {
+              return `integer('${name}', {
+								mode: "boolean"
+							})`;
+            }
+            return `boolean('${name}')`;
+          }
+          if (type === "date") {
+            if (databaseType === "sqlite") {
+              return `integer('${name}', {
+								mode: "timestamp"
+							})`;
+            }
+            return `timestamp('${name}')`;
+          }
+        };
+        var getType = getType2;
+        const tableName = tables[table].tableName;
+        const fields = tables[table].fields;
+        const schema2 = `export const ${table} = ${databaseType}Table("${tableName}", {
+					id: text("id").primaryKey(),
+					${Object.keys(fields).map((field) => {
+          const attr = fields[field];
+          return `${field}: ${getType2(field, attr.type)}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${attr.references.model}.${attr.references.field})` : ""}`;
+        }).join()}
+				});`;
+        code += `
+${schema2}
+`;
+      }
+      if (fileExist) {
+        if (fileContent.includes(code)) {
+          return {
+            code: "",
+            fileName: filePath,
+            append: false
+          };
+        }
+        if (fileContent.includes("import")) {
+          code = code.replace(/import {.*?} from "drizzle-orm\/.*?";/, "");
+        }
+      }
+      const formattedCode = await prettier.format(code, {
+        semi: true,
+        parser: "typescript",
+        tabWidth: 4
+      });
+      return {
+        code: formattedCode,
+        fileName: filePath,
+        append: fileExist
+      };
+    }
+  };
+};
+export {
+  drizzleAdapter
+};

package/dist/adapters/mongodb.d.ts

@@ -0,0 +1,36 @@
+import { W as Where } from '../index-CcdDoX76.js';
+import 'kysely';
+import '../index-CE92ti2Z.js';
+import 'arctic';
+import 'zod';
+import '../helper-C1ihmerM.js';
+import 'better-call';
+
+declare const mongodbAdapter: (mongo: any) => {
+    id: string;
+    create<T, 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[];
+    }): Promise<any>;
+    update<T>(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }): Promise<any>;
+    delete<T>(data: {
+        model: string;
+        where: Where[];
+    }): Promise<any>;
+};
+
+export { mongodbAdapter };

package/dist/adapters/mongodb.js

@@ -0,0 +1,102 @@
+// src/adapters/mongodb-adapter/index.ts
+function whereConvertor(where) {
+  if (!where) return {};
+  if (where.length === 1) {
+    const w = where[0];
+    if (!w) {
+      return;
+    }
+    return {
+      [w.field]: w.value
+    };
+  }
+  const and = where.filter((w) => w.connector === "AND" || !w.connector);
+  const or = where.filter((w) => w.connector === "OR");
+  const andClause = and.map((w) => {
+    return {
+      [w.field]: w.operator === "eq" || !w.operator ? w.value : {
+        [w.field]: w.value
+      }
+    };
+  });
+  const orClause = or.map((w) => {
+    return {
+      [w.field]: w.value
+    };
+  });
+  let clause = {};
+  if (andClause.length) {
+    clause = { ...clause, $and: andClause };
+  }
+  if (orClause.length) {
+    clause = { ...clause, $or: orClause };
+  }
+  return clause;
+}
+function removeMongoId(data) {
+  const { _id, ...rest } = data;
+  return rest;
+}
+function selectConvertor(selects) {
+  const selectConstruct = selects.reduce((acc, field) => {
+    acc[field] = 1;
+    return acc;
+  }, {});
+  return selectConstruct;
+}
+var mongodbAdapter = (mongo) => {
+  const db = mongo;
+  return {
+    id: "mongodb",
+    async create(data) {
+      const { model, data: val } = data;
+      const res = await db.collection(model).insertOne({
+        ...val
+      });
+      const id_ = res.insertedId;
+      const returned = { id: id_, ...val };
+      return removeMongoId(returned);
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const wheres = whereConvertor(where);
+      let selects = {};
+      if (select) {
+        selects = selectConvertor(select);
+      }
+      const res = await db.collection(model).find({ ...wheres }, { projection: selects }).toArray();
+      const result = res[0];
+      if (!result) {
+        return null;
+      }
+      return removeMongoId(result);
+    },
+    async findMany(data) {
+      const { model, where } = data;
+      const wheres = whereConvertor(where);
+      const toReturn = await db.collection(model).findMany(wheres);
+      return removeMongoId(toReturn);
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      const wheres = whereConvertor(where);
+      const res = await db.collection(model).findOneAndUpdate(
+        wheres,
+        {
+          $set: update
+        },
+        { returnDocument: "after" }
+      );
+      return removeMongoId(res);
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const wheres = whereConvertor(where);
+      const res = await db.collection(model).findOneAndDelete(wheres);
+      return res;
+    }
+  };
+};
+export {
+  mongodbAdapter
+};

package/dist/adapters/prisma.d.ts

@@ -0,0 +1,13 @@
+import { A as Adapter } from '../index-CcdDoX76.js';
+import 'kysely';
+import '../index-CE92ti2Z.js';
+import 'arctic';
+import 'zod';
+import '../helper-C1ihmerM.js';
+import 'better-call';
+
+declare const prismaAdapter: (prisma: any, { provider, }: {
+    provider: "sqlite" | "cockroachdb" | "mysql" | "postgresql" | "sqlserver";
+}) => Adapter;
+
+export { prismaAdapter };