better-auth 1.2.0-beta.9 → 1.2.1-beta.1

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

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

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

@@ -0,0 +1,22 @@
+export { c as createKyselyAdapter, k as kyselyAdapter } from '../../shared/better-auth.HHZU10im.mjs';
+import 'kysely';
+import '../../shared/better-auth.C24Bzw4w.mjs';
+import 'zod';
+import 'better-call';
+import '../../shared/better-auth.8zoxzg-F.mjs';
+import '../../shared/better-auth.BUPPRXfK.mjs';
+import '@better-auth/utils/random';
+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 '../../shared/better-auth.DORkW_Ge.mjs';
+import '../../shared/better-auth.0TC26uRi.mjs';

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

@@ -0,0 +1,57 @@
+import type { BetterAuthOptions, Where } from "../../types";
+import type { KyselyDatabaseType } from "./types";
+import type { Kysely } from "kysely";
+interface KyselyAdapterConfig {
+    /**
+     * Database type.
+     */
+    type?: KyselyDatabaseType;
+}
+export declare const kyselyAdapter: (db: Kysely<any>, config?: KyselyAdapterConfig) => (opts: 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[]>;
+    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>;
+    count(data: {
+        model: string;
+        where?: Where[];
+    }): Promise<number>;
+    delete<T>(data: {
+        model: string;
+        where: Where[];
+    }): Promise<void>;
+    deleteMany(data: {
+        model: string;
+        where: Where[];
+    }): Promise<number>;
+    options: KyselyAdapterConfig | undefined;
+};
+export {};
+//# sourceMappingURL=kysely-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/kysely-adapter/kysely-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAW,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,KAAK,EAAsB,MAAM,EAAsB,MAAM,QAAQ,CAAC;AAE7E,UAAU,mBAAmB;IAC5B;;OAEG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC1B;AAoOD,eAAO,MAAM,aAAa,GACxB,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,SAAS,mBAAmB,MAC7C,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoJvB,CAAC"}

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

@@ -0,0 +1,2 @@
+export type KyselyDatabaseType = "postgres" | "mysql" | "sqlite" | "mssql";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapters/kysely-adapter/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC"}

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

@@ -0,0 +1,28 @@
+'use strict';
+
+const memoryAdapter = require('../../shared/better-auth.DZnoWLte.cjs');
+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('kysely');
+require('../../shared/better-auth.CUdxApHl.cjs');
+
+
+
+exports.memoryAdapter = memoryAdapter.memoryAdapter;

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

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

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

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

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

@@ -0,0 +1,22 @@
+export { m as memoryAdapter } from '../../shared/better-auth.D8LeJoj0.mjs';
+import '../../shared/better-auth.C24Bzw4w.mjs';
+import 'zod';
+import 'better-call';
+import '../../shared/better-auth.8zoxzg-F.mjs';
+import '../../shared/better-auth.BUPPRXfK.mjs';
+import '@better-auth/utils/random';
+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 '../../shared/better-auth.DORkW_Ge.mjs';
+import 'kysely';
+import '../../shared/better-auth.0TC26uRi.mjs';

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

@@ -0,0 +1,50 @@
+import type { BetterAuthOptions, Where } from "../../types";
+export interface MemoryDB {
+    [key: string]: any[];
+}
+export declare const memoryAdapter: (db: MemoryDB) => (options: BetterAuthOptions) => {
+    id: string;
+    create: <T extends Record<string, any>, R = T>({ model, data }: {
+        model: string;
+        data: T;
+        select?: string[];
+    }) => Promise<any>;
+    findOne: <T>({ model, where, select }: {
+        model: string;
+        where: Where[];
+        select?: string[];
+    }) => Promise<any>;
+    findMany: <T>({ model, where, sortBy, limit, offset }: {
+        model: string;
+        where?: Where[];
+        limit?: number;
+        sortBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        };
+        offset?: number;
+    }) => Promise<any[]>;
+    count: ({ model }: {
+        model: string;
+        where?: Where[];
+    }) => Promise<number>;
+    update: <T>({ model, where, update }: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }) => Promise<any>;
+    delete: <T>({ model, where }: {
+        model: string;
+        where: Where[];
+    }) => Promise<void>;
+    deleteMany: ({ model, where }: {
+        model: string;
+        where: Where[];
+    }) => Promise<number>;
+    updateMany(data: {
+        model: string;
+        where: Where[];
+        update: Record<string, any>;
+    }): any;
+};
+//# sourceMappingURL=memory-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/memory-adapter/memory-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAW,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIrE,MAAM,WAAW,QAAQ;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;CACrB;AAgGD,eAAO,MAAM,aAAa,GAAI,IAAI,QAAQ,MAAM,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+EzE,CAAC"}

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

@@ -0,0 +1,282 @@
+'use strict';
+
+const mongodb = require('mongodb');
+require('../../shared/better-auth.CHyZMcYK.cjs');
+require('../../shared/better-auth.DiSjtgs9.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');
+const getTables = require('../../shared/better-auth.BEphVDyL.cjs');
+require('kysely');
+const utils = require('../../shared/better-auth.CUdxApHl.cjs');
+
+const createTransform = (options) => {
+  const schema = getTables.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 mongodb.ObjectId) {
+          return value;
+        }
+        if (Array.isArray(value)) {
+          return value.map((v) => {
+            if (typeof v === "string") {
+              try {
+                return new mongodb.ObjectId(v);
+              } catch (e) {
+                return v;
+              }
+            }
+            if (v instanceof mongodb.ObjectId) {
+              return v;
+            }
+            throw new Error("Invalid id value");
+          });
+        }
+        throw new Error("Invalid id value");
+      }
+      try {
+        return new mongodb.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 mongodb.ObjectId) {
+        return value.toHexString();
+      }
+      if (Array.isArray(value)) {
+        return value.map((v) => {
+          if (v instanceof mongodb.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 mongodb.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] = utils.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;
+    }
+  };
+};
+
+exports.mongodbAdapter = mongodbAdapter;

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

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

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

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