better-auth 1.2.0-beta.16 → 1.2.0-beta.19

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

@@ -0,0 +1,280 @@
+import { ObjectId } from 'mongodb';
+import '../../shared/better-auth.C24Bzw4w.mjs';
+import '../../shared/better-auth.8zoxzg-F.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.DH3YjMQH.mjs';
+import { g as getAuthTables } from '../../shared/better-auth.DORkW_Ge.mjs';
+import 'kysely';
+import { w as withApplyDefault } from '../../shared/better-auth.0TC26uRi.mjs';
+
+const createTransform = (options) => {
+  const schema = getAuthTables(options);
+  const customIdGen = options.advanced?.generateId;
+  function serializeID(field, value, model) {
+    if (customIdGen) {
+      return value;
+    }
+    if (field === "id" || field === "_id" || schema[model].fields[field].references?.field === "id") {
+      if (typeof value !== "string") {
+        if (value instanceof ObjectId) {
+          return value;
+        }
+        if (Array.isArray(value)) {
+          return value.map((v) => {
+            if (typeof v === "string") {
+              try {
+                return new ObjectId(v);
+              } catch (e) {
+                return v;
+              }
+            }
+            if (v instanceof ObjectId) {
+              return v;
+            }
+            throw new Error("Invalid id value");
+          });
+        }
+        throw new Error("Invalid id value");
+      }
+      try {
+        return new ObjectId(value);
+      } catch (e) {
+        return value;
+      }
+    }
+    return value;
+  }
+  function deserializeID(field, value, model) {
+    if (customIdGen) {
+      return value;
+    }
+    if (field === "id" || schema[model].fields[field].references?.field === "id") {
+      if (value instanceof ObjectId) {
+        return value.toHexString();
+      }
+      if (Array.isArray(value)) {
+        return value.map((v) => {
+          if (v instanceof ObjectId) {
+            return v.toHexString();
+          }
+          return v;
+        });
+      }
+      return value;
+    }
+    return value;
+  }
+  function getField(field, model) {
+    if (field === "id") {
+      if (customIdGen) {
+        return "id";
+      }
+      return "_id";
+    }
+    const f = schema[model].fields[field];
+    return f.fieldName || field;
+  }
+  return {
+    transformInput(data, model, action) {
+      const transformedData = action === "update" ? {} : customIdGen ? {
+        id: customIdGen({ model })
+      } : {
+        _id: new ObjectId()
+      };
+      const fields = schema[model].fields;
+      for (const field in fields) {
+        const value = data[field];
+        if (value === void 0 && (!fields[field].defaultValue || action === "update")) {
+          continue;
+        }
+        transformedData[fields[field].fieldName || field] = withApplyDefault(
+          serializeID(field, value, model),
+          fields[field],
+          action
+        );
+      }
+      return transformedData;
+    },
+    transformOutput(data, model, select = []) {
+      const transformedData = data.id || data._id ? select.length === 0 || select.includes("id") ? {
+        id: data.id ? data.id.toString() : data._id.toString()
+      } : {} : {};
+      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] = deserializeID(
+            key,
+            data[field.fieldName || key],
+            model
+          );
+        }
+      }
+      return transformedData;
+    },
+    convertWhereClause(where, model) {
+      if (!where.length) return {};
+      const conditions = where.map((w) => {
+        const { field: _field, value, operator = "eq", connector = "AND" } = w;
+        let condition;
+        const field = getField(_field, model);
+        switch (operator.toLowerCase()) {
+          case "eq":
+            condition = {
+              [field]: serializeID(_field, value, model)
+            };
+            break;
+          case "in":
+            condition = {
+              [field]: {
+                $in: Array.isArray(value) ? serializeID(_field, value, model) : [serializeID(_field, value, model)]
+              }
+            };
+            break;
+          case "gt":
+            condition = { [field]: { $gt: value } };
+            break;
+          case "gte":
+            condition = { [field]: { $gte: value } };
+            break;
+          case "lt":
+            condition = { [field]: { $lt: value } };
+            break;
+          case "lte":
+            condition = { [field]: { $lte: value } };
+            break;
+          case "ne":
+            condition = { [field]: { $ne: value } };
+            break;
+          case "contains":
+            condition = { [field]: { $regex: `.*${value}.*` } };
+            break;
+          case "starts_with":
+            condition = { [field]: { $regex: `${value}.*` } };
+            break;
+          case "ends_with":
+            condition = { [field]: { $regex: `.*${value}` } };
+            break;
+          default:
+            throw new Error(`Unsupported operator: ${operator}`);
+        }
+        return { condition, connector };
+      });
+      if (conditions.length === 1) {
+        return conditions[0].condition;
+      }
+      const andConditions = conditions.filter((c) => c.connector === "AND").map((c) => c.condition);
+      const orConditions = conditions.filter((c) => c.connector === "OR").map((c) => c.condition);
+      let clause = {};
+      if (andConditions.length) {
+        clause = { ...clause, $and: andConditions };
+      }
+      if (orConditions.length) {
+        clause = { ...clause, $or: orConditions };
+      }
+      return clause;
+    },
+    getModelName: (model) => {
+      return schema[model].modelName;
+    },
+    getField
+  };
+};
+const mongodbAdapter = (db) => (options) => {
+  const transform = createTransform(options);
+  const hasCustomId = options.advanced?.generateId;
+  return {
+    id: "mongodb-adapter",
+    async create(data) {
+      const { model, data: values, select } = data;
+      const transformedData = transform.transformInput(values, model, "create");
+      if (transformedData.id && !hasCustomId) {
+        delete transformedData.id;
+      }
+      const res = await db.collection(transform.getModelName(model)).insertOne(transformedData);
+      const id = res.insertedId;
+      const insertedData = { id: id.toString(), ...transformedData };
+      const t = transform.transformOutput(insertedData, model, select);
+      return t;
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const clause = transform.convertWhereClause(where, model);
+      const res = await db.collection(transform.getModelName(model)).findOne(clause);
+      if (!res) return null;
+      const transformedData = transform.transformOutput(res, model, select);
+      return transformedData;
+    },
+    async findMany(data) {
+      const { model, where, limit, offset, sortBy } = data;
+      const clause = where ? transform.convertWhereClause(where, model) : {};
+      const cursor = db.collection(transform.getModelName(model)).find(clause);
+      if (limit) cursor.limit(limit);
+      if (offset) cursor.skip(offset);
+      if (sortBy)
+        cursor.sort(
+          transform.getField(sortBy.field, model),
+          sortBy.direction === "desc" ? -1 : 1
+        );
+      const res = await cursor.toArray();
+      return res.map((r) => transform.transformOutput(r, model));
+    },
+    async count(data) {
+      const { model } = data;
+      const res = await db.collection(transform.getModelName(model)).countDocuments();
+      return res;
+    },
+    async update(data) {
+      const { model, where, update: values } = data;
+      const clause = transform.convertWhereClause(where, model);
+      const transformedData = transform.transformInput(values, model, "update");
+      const res = await db.collection(transform.getModelName(model)).findOneAndUpdate(
+        clause,
+        { $set: transformedData },
+        {
+          returnDocument: "after"
+        }
+      );
+      if (!res) return null;
+      return transform.transformOutput(res, model);
+    },
+    async updateMany(data) {
+      const { model, where, update: values } = data;
+      const clause = transform.convertWhereClause(where, model);
+      const transformedData = transform.transformInput(values, model, "update");
+      const res = await db.collection(transform.getModelName(model)).updateMany(clause, { $set: transformedData });
+      return res.modifiedCount;
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const clause = transform.convertWhereClause(where, model);
+      const res = await db.collection(transform.getModelName(model)).findOneAndDelete(clause);
+      if (!res) return null;
+      return transform.transformOutput(res, model);
+    },
+    async deleteMany(data) {
+      const { model, where } = data;
+      const clause = transform.convertWhereClause(where, model);
+      const res = await db.collection(transform.getModelName(model)).deleteMany(clause);
+      return res.deletedCount;
+    }
+  };
+};
+
+export { mongodbAdapter };

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

@@ -0,0 +1,48 @@
+import { type Db } from "mongodb";
+import type { BetterAuthOptions, Where } from "../../types";
+export declare const mongodbAdapter: (db: Db) => (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<number>;
+    update<T>(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }): Promise<any>;
+    updateMany(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }): Promise<number>;
+    delete<T>(data: {
+        model: string;
+        where: Where[];
+    }): Promise<any>;
+    deleteMany(data: {
+        model: string;
+        where: Where[];
+    }): Promise<number>;
+};
+//# sourceMappingURL=mongodb-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/mongodb-adapter/mongodb-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,EAAE,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAW,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAgOrE,eAAO,MAAM,cAAc,GAAI,IAAI,EAAE,MAAM,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGpE,CAAC"}

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

@@ -0,0 +1,254 @@
+'use strict';
+
+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 = (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 operatorToPrismaOperator(operator) {
+    switch (operator) {
+      case "starts_with":
+        return "startsWith";
+      case "ends_with":
+        return "endsWith";
+      default:
+        return operator;
+    }
+  }
+  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 || id.generateId()
+      };
+      const fields = schema[model].fields;
+      for (const field in fields) {
+        const value = data[field];
+        if (value === void 0 && (!fields[field].defaultValue || action === "update")) {
+          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(model, where) {
+      if (!where) return {};
+      if (where.length === 1) {
+        const w = where[0];
+        if (!w) {
+          return;
+        }
+        return {
+          [getField(model, w.field)]: w.operator === "eq" || !w.operator ? w.value : {
+            [operatorToPrismaOperator(w.operator)]: 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 {
+          [getField(model, w.field)]: w.operator === "eq" || !w.operator ? w.value : {
+            [operatorToPrismaOperator(w.operator)]: w.value
+          }
+        };
+      });
+      const orClause = or.map((w) => {
+        return {
+          [getField(model, w.field)]: {
+            [w.operator || "eq"]: w.value
+          }
+        };
+      });
+      return {
+        ...andClause.length ? { AND: andClause } : {},
+        ...orClause.length ? { OR: orClause } : {}
+      };
+    },
+    convertSelect: (select, model) => {
+      if (!select || !model) return void 0;
+      return select.reduce((prev, cur) => {
+        return {
+          ...prev,
+          [getField(model, cur)]: true
+        };
+      }, {});
+    },
+    getModelName,
+    getField
+  };
+};
+const prismaAdapter = (prisma, config) => (options) => {
+  const db = prisma;
+  const {
+    transformInput,
+    transformOutput,
+    convertWhereClause,
+    convertSelect,
+    getModelName,
+    getField
+  } = createTransform(config, options);
+  return {
+    id: "prisma",
+    async create(data) {
+      const { model, data: values, select } = data;
+      const transformed = transformInput(values, model, "create");
+      if (!db[getModelName(model)]) {
+        throw new index.BetterAuthError(
+          `Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`
+        );
+      }
+      const result = await db[getModelName(model)].create({
+        data: transformed,
+        select: convertSelect(select, model)
+      });
+      return transformOutput(result, model, select);
+    },
+    async findOne(data) {
+      const { model, where, select } = data;
+      const whereClause = convertWhereClause(model, where);
+      if (!db[getModelName(model)]) {
+        throw new index.BetterAuthError(
+          `Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`
+        );
+      }
+      const result = await db[getModelName(model)].findFirst({
+        where: whereClause,
+        select: convertSelect(select, model)
+      });
+      return transformOutput(result, model, select);
+    },
+    async findMany(data) {
+      const { model, where, limit, offset, sortBy } = data;
+      const whereClause = convertWhereClause(model, where);
+      if (!db[getModelName(model)]) {
+        throw new index.BetterAuthError(
+          `Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`
+        );
+      }
+      const result = await db[getModelName(model)].findMany({
+        where: whereClause,
+        take: limit || 100,
+        skip: offset || 0,
+        ...sortBy?.field ? {
+          orderBy: {
+            [getField(model, sortBy.field)]: sortBy.direction === "desc" ? "desc" : "asc"
+          }
+        } : {}
+      });
+      return result.map((r) => transformOutput(r, model));
+    },
+    async count(data) {
+      const { model, where } = data;
+      const whereClause = convertWhereClause(model, where);
+      if (!db[getModelName(model)]) {
+        throw new index.BetterAuthError(
+          `Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`
+        );
+      }
+      const result = await db[getModelName(model)].count({
+        where: whereClause
+      });
+      return result;
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      if (!db[getModelName(model)]) {
+        throw new index.BetterAuthError(
+          `Model ${model} does not exist in the database. If you haven't generated the Prisma client, you need to run 'npx prisma generate'`
+        );
+      }
+      const whereClause = convertWhereClause(model, where);
+      const transformed = transformInput(update, model, "update");
+      const result = await db[getModelName(model)].update({
+        where: whereClause,
+        data: transformed
+      });
+      return transformOutput(result, model);
+    },
+    async updateMany(data) {
+      const { model, where, update } = data;
+      const whereClause = convertWhereClause(model, where);
+      const transformed = transformInput(update, model, "update");
+      const result = await db[getModelName(model)].updateMany({
+        where: whereClause,
+        data: transformed
+      });
+      return result ? result.count : 0;
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const whereClause = convertWhereClause(model, where);
+      try {
+        await db[getModelName(model)].delete({
+          where: whereClause
+        });
+      } catch (e) {
+      }
+    },
+    async deleteMany(data) {
+      const { model, where } = data;
+      const whereClause = convertWhereClause(model, where);
+      const result = await db[getModelName(model)].deleteMany({
+        where: whereClause
+      });
+      return result ? result.count : 0;
+    },
+    options: config
+  };
+};
+
+exports.prismaAdapter = prismaAdapter;

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

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

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

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