@coursebuilder/better-auth 0.1.0-canary.0.0c9beb2ae

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Skill Recordings Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,289 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  courseBuilderBetterAuthAdapter: () => courseBuilderBetterAuthAdapter
+});
+module.exports = __toCommonJS(src_exports);
+var import_adapters = require("better-auth/adapters");
+var import_drizzle_orm = require("drizzle-orm");
+var accountFields = {
+  accessToken: "access_token",
+  accessTokenExpiresAt: "expires_at",
+  idToken: "id_token",
+  refreshToken: "refresh_token",
+  refreshTokenExpiresAt: "refresh_token_expires_in",
+  tokenType: "token_type",
+  sessionState: "session_state"
+};
+function accountId(record) {
+  return `${String(record.provider)}:${String(record.providerAccountId)}`;
+}
+function toEpochSeconds(value) {
+  return value instanceof Date ? Math.floor(value.getTime() / 1e3) : value;
+}
+function fromEpochSeconds(value) {
+  return typeof value === "number" ? new Date(value * 1e3) : value;
+}
+function toStorage(model, data) {
+  if (model === "session") {
+    const { token, expiresAt, ...rest } = data;
+    return { ...rest, sessionToken: token, expires: expiresAt };
+  }
+  if (model === "account") {
+    const { id: _id, providerId, accountId: providerAccountId, ...rest } = data;
+    return Object.fromEntries(
+      Object.entries({ ...rest, provider: providerId, providerAccountId }).filter(([key]) => key !== "createdAt" && key !== "updatedAt").map(([key, value]) => [
+        accountFields[key] ?? key,
+        key === "accessTokenExpiresAt" || key === "refreshTokenExpiresAt" ? toEpochSeconds(value) : value
+      ])
+    );
+  }
+  if (model === "verification") {
+    const { value, expiresAt, id: _id, ...rest } = data;
+    return { ...rest, token: value, expires: expiresAt };
+  }
+  if (model === "user") {
+    const { updatedAt: _updatedAt, ...rest } = data;
+    return {
+      ...rest,
+      emailVerified: data.emailVerified ? /* @__PURE__ */ new Date() : null
+    };
+  }
+  return data;
+}
+function fromStorage(model, data) {
+  if (model === "session") {
+    const { sessionToken, expires, ...rest } = data;
+    return {
+      ...rest,
+      id: sessionToken,
+      token: sessionToken,
+      expiresAt: expires
+    };
+  }
+  if (model === "account") {
+    const translated = Object.fromEntries(
+      Object.entries(data).map(([key, value]) => {
+        const field = Object.entries(accountFields).find(
+          ([, storage]) => storage === key
+        )?.[0] ?? key;
+        return [
+          field,
+          field === "accessTokenExpiresAt" || field === "refreshTokenExpiresAt" ? fromEpochSeconds(value) : value
+        ];
+      })
+    );
+    return {
+      ...translated,
+      id: accountId(data),
+      providerId: data.provider,
+      accountId: data.providerAccountId
+    };
+  }
+  if (model === "verification") {
+    const { token, expires, ...rest } = data;
+    return {
+      ...rest,
+      id: `${String(data.identifier)}:${String(token)}`,
+      value: token,
+      expiresAt: expires
+    };
+  }
+  if (model === "user") {
+    return { ...data, emailVerified: data.emailVerified instanceof Date };
+  }
+  return data;
+}
+function storageField(model, field, value) {
+  if (model === "session") {
+    if (field === "token" || field === "id")
+      return ["sessionToken", value];
+    if (field === "expiresAt")
+      return ["expires", value];
+  }
+  if (model === "account") {
+    if (field === "providerId")
+      return ["provider", value];
+    if (field === "accountId")
+      return ["providerAccountId", value];
+    if (field === "id" && typeof value === "string") {
+      const separator = value.indexOf(":");
+      return separator < 0 ? ["providerAccountId", value] : ["providerAccountId", value.slice(separator + 1)];
+    }
+    return [accountFields[field] ?? field, value];
+  }
+  if (model === "verification") {
+    if (field === "value")
+      return ["token", value];
+    if (field === "expiresAt")
+      return ["expires", value];
+  }
+  if (model === "user" && field === "emailVerified" && typeof value === "boolean") {
+    return ["emailVerified", value ? /* @__PURE__ */ new Date(0) : null];
+  }
+  return [field, value];
+}
+function predicate(table, model, where) {
+  const expressions = where.map((condition) => {
+    if (model === "account" && condition.field === "id" && typeof condition.value === "string" && condition.value.includes(":")) {
+      const separator = condition.value.indexOf(":");
+      const provider = table["provider"];
+      const providerAccountId = table["providerAccountId"];
+      return (0, import_drizzle_orm.and)(
+        (0, import_drizzle_orm.eq)(provider, condition.value.slice(0, separator)),
+        (0, import_drizzle_orm.eq)(providerAccountId, condition.value.slice(separator + 1))
+      );
+    }
+    const [field, value] = storageField(model, condition.field, condition.value);
+    const column = table[field];
+    switch (condition.operator) {
+      case "ne":
+        return (0, import_drizzle_orm.ne)(column, value);
+      case "lt":
+        return (0, import_drizzle_orm.lt)(column, value);
+      case "lte":
+        return (0, import_drizzle_orm.lte)(column, value);
+      case "gt":
+        return (0, import_drizzle_orm.gt)(column, value);
+      case "gte":
+        return (0, import_drizzle_orm.gte)(column, value);
+      case "in":
+        return (0, import_drizzle_orm.inArray)(column, value);
+      case "not_in":
+        return (0, import_drizzle_orm.notInArray)(column, value);
+      case "contains":
+        return (0, import_drizzle_orm.like)(column, `%${String(value)}%`);
+      case "starts_with":
+        return (0, import_drizzle_orm.like)(column, `${String(value)}%`);
+      case "ends_with":
+        return (0, import_drizzle_orm.like)(column, `%${String(value)}`);
+      default:
+        return (0, import_drizzle_orm.eq)(column, value);
+    }
+  });
+  if (!expressions.length)
+    return void 0;
+  const groups = [];
+  let current = [];
+  for (let index = 0; index < expressions.length; index++) {
+    current.push(expressions[index]);
+    if (where[index]?.connector === "OR") {
+      groups.push((0, import_drizzle_orm.and)(...current));
+      current = [];
+    }
+  }
+  if (current.length)
+    groups.push((0, import_drizzle_orm.and)(...current));
+  return groups.length === 1 ? groups[0] : (0, import_drizzle_orm.or)(...groups);
+}
+function courseBuilderBetterAuthAdapter(options) {
+  const { db, tables } = options;
+  return (0, import_adapters.createAdapterFactory)({
+    config: {
+      adapterId: "coursebuilder",
+      adapterName: "Course Builder",
+      debugLogs: options.debugLogs ?? false,
+      supportsDates: true,
+      supportsBooleans: true,
+      supportsJSON: true,
+      supportsNumericIds: false,
+      transaction: false
+    },
+    adapter: ({ getDefaultModelName }) => {
+      const resolve = (model) => {
+        const canonical = getDefaultModelName(model);
+        const table = tables[canonical];
+        if (!table)
+          throw new Error(`Unsupported Better Auth model: ${model}`);
+        return { canonical, table };
+      };
+      return {
+        create: async ({ model, data }) => {
+          const { canonical, table } = resolve(model);
+          await db.insert(table).values(toStorage(canonical, data));
+          return data;
+        },
+        findOne: async ({ model, where, join }) => {
+          const { canonical, table } = resolve(model);
+          const [row] = await db.select().from(table).where(predicate(table, canonical, where)).limit(1);
+          if (!row)
+            return null;
+          const result = fromStorage(canonical, row);
+          if (canonical === "session" && join?.user) {
+            const userId = tables.user["id"];
+            const [user] = await db.select().from(tables.user).where((0, import_drizzle_orm.eq)(userId, row.userId)).limit(1);
+            if (user)
+              result.user = fromStorage("user", user);
+          }
+          return result;
+        },
+        findMany: async ({ model, where, limit, offset, sortBy }) => {
+          const { canonical, table } = resolve(model);
+          let query = db.select().from(table).$dynamic();
+          const filter = where ? predicate(table, canonical, where) : void 0;
+          if (filter)
+            query = query.where(filter);
+          if (sortBy) {
+            const [field] = storageField(canonical, sortBy.field, null);
+            const column = table[field];
+            query = query.orderBy(
+              sortBy.direction === "asc" ? (0, import_drizzle_orm.asc)(column) : (0, import_drizzle_orm.desc)(column)
+            );
+          }
+          const rows = await query.limit(limit).offset(offset ?? 0);
+          return rows.map((row) => fromStorage(canonical, row));
+        },
+        update: async ({ model, where, update }) => {
+          const { canonical, table } = resolve(model);
+          await db.update(table).set(
+            toStorage(canonical, update)
+          ).where(predicate(table, canonical, where));
+          const [row] = await db.select().from(table).where(predicate(table, canonical, where)).limit(1);
+          return row ? fromStorage(canonical, row) : null;
+        },
+        updateMany: async ({ model, where, update }) => {
+          const { canonical, table } = resolve(model);
+          const result = await db.update(table).set(toStorage(canonical, update)).where(predicate(table, canonical, where));
+          return Number(result[0].affectedRows);
+        },
+        delete: async ({ model, where }) => {
+          const { canonical, table } = resolve(model);
+          await db.delete(table).where(predicate(table, canonical, where));
+        },
+        deleteMany: async ({ model, where }) => {
+          const { canonical, table } = resolve(model);
+          const result = await db.delete(table).where(predicate(table, canonical, where));
+          return Number(result[0].affectedRows);
+        },
+        count: async ({ model, where }) => {
+          const { canonical, table } = resolve(model);
+          const [result] = await db.select({ count: (0, import_drizzle_orm.count)() }).from(table).where(where ? predicate(table, canonical, where) : void 0);
+          return Number(result?.count ?? 0);
+        }
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  courseBuilderBetterAuthAdapter
+});

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+import { DBAdapterDebugLogOption, createAdapterFactory } from 'better-auth/adapters';
+import { MySqlDatabase, MySqlTable } from 'drizzle-orm/mysql-core';
+
+type CourseBuilderBetterAuthTables = {
+    user: MySqlTable;
+    session: MySqlTable;
+    account: MySqlTable;
+    verification: MySqlTable;
+};
+type CourseBuilderBetterAuthAdapterOptions = {
+    db: InstanceType<typeof MySqlDatabase>;
+    tables: CourseBuilderBetterAuthTables;
+    debugLogs?: DBAdapterDebugLogOption;
+};
+/**
+ * Creates a Better Auth database adapter over Course Builder's existing MySQL
+ * auth tables. This is a translation boundary only and never creates schema.
+ *
+ * @param options - Existing Drizzle database and canonical CB auth tables.
+ * @returns A Better Auth database adapter factory.
+ *
+ * @example
+ * ```ts
+ * const database = courseBuilderBetterAuthAdapter({ db, tables })
+ * ```
+ */
+declare function courseBuilderBetterAuthAdapter(options: CourseBuilderBetterAuthAdapterOptions): ReturnType<typeof createAdapterFactory>;
+
+export { type CourseBuilderBetterAuthAdapterOptions, type CourseBuilderBetterAuthTables, courseBuilderBetterAuthAdapter };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { DBAdapterDebugLogOption, createAdapterFactory } from 'better-auth/adapters';
+import { MySqlDatabase, MySqlTable } from 'drizzle-orm/mysql-core';
+
+type CourseBuilderBetterAuthTables = {
+    user: MySqlTable;
+    session: MySqlTable;
+    account: MySqlTable;
+    verification: MySqlTable;
+};
+type CourseBuilderBetterAuthAdapterOptions = {
+    db: InstanceType<typeof MySqlDatabase>;
+    tables: CourseBuilderBetterAuthTables;
+    debugLogs?: DBAdapterDebugLogOption;
+};
+/**
+ * Creates a Better Auth database adapter over Course Builder's existing MySQL
+ * auth tables. This is a translation boundary only and never creates schema.
+ *
+ * @param options - Existing Drizzle database and canonical CB auth tables.
+ * @returns A Better Auth database adapter factory.
+ *
+ * @example
+ * ```ts
+ * const database = courseBuilderBetterAuthAdapter({ db, tables })
+ * ```
+ */
+declare function courseBuilderBetterAuthAdapter(options: CourseBuilderBetterAuthAdapterOptions): ReturnType<typeof createAdapterFactory>;
+
+export { type CourseBuilderBetterAuthAdapterOptions, type CourseBuilderBetterAuthTables, courseBuilderBetterAuthAdapter };

package/dist/index.js

@@ -0,0 +1,281 @@
+// src/index.ts
+import {
+  createAdapterFactory
+} from "better-auth/adapters";
+import {
+  and,
+  asc,
+  count,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  like,
+  lt,
+  lte,
+  ne,
+  notInArray,
+  or
+} from "drizzle-orm";
+var accountFields = {
+  accessToken: "access_token",
+  accessTokenExpiresAt: "expires_at",
+  idToken: "id_token",
+  refreshToken: "refresh_token",
+  refreshTokenExpiresAt: "refresh_token_expires_in",
+  tokenType: "token_type",
+  sessionState: "session_state"
+};
+function accountId(record) {
+  return `${String(record.provider)}:${String(record.providerAccountId)}`;
+}
+function toEpochSeconds(value) {
+  return value instanceof Date ? Math.floor(value.getTime() / 1e3) : value;
+}
+function fromEpochSeconds(value) {
+  return typeof value === "number" ? new Date(value * 1e3) : value;
+}
+function toStorage(model, data) {
+  if (model === "session") {
+    const { token, expiresAt, ...rest } = data;
+    return { ...rest, sessionToken: token, expires: expiresAt };
+  }
+  if (model === "account") {
+    const { id: _id, providerId, accountId: providerAccountId, ...rest } = data;
+    return Object.fromEntries(
+      Object.entries({ ...rest, provider: providerId, providerAccountId }).filter(([key]) => key !== "createdAt" && key !== "updatedAt").map(([key, value]) => [
+        accountFields[key] ?? key,
+        key === "accessTokenExpiresAt" || key === "refreshTokenExpiresAt" ? toEpochSeconds(value) : value
+      ])
+    );
+  }
+  if (model === "verification") {
+    const { value, expiresAt, id: _id, ...rest } = data;
+    return { ...rest, token: value, expires: expiresAt };
+  }
+  if (model === "user") {
+    const { updatedAt: _updatedAt, ...rest } = data;
+    return {
+      ...rest,
+      emailVerified: data.emailVerified ? /* @__PURE__ */ new Date() : null
+    };
+  }
+  return data;
+}
+function fromStorage(model, data) {
+  if (model === "session") {
+    const { sessionToken, expires, ...rest } = data;
+    return {
+      ...rest,
+      id: sessionToken,
+      token: sessionToken,
+      expiresAt: expires
+    };
+  }
+  if (model === "account") {
+    const translated = Object.fromEntries(
+      Object.entries(data).map(([key, value]) => {
+        const field = Object.entries(accountFields).find(
+          ([, storage]) => storage === key
+        )?.[0] ?? key;
+        return [
+          field,
+          field === "accessTokenExpiresAt" || field === "refreshTokenExpiresAt" ? fromEpochSeconds(value) : value
+        ];
+      })
+    );
+    return {
+      ...translated,
+      id: accountId(data),
+      providerId: data.provider,
+      accountId: data.providerAccountId
+    };
+  }
+  if (model === "verification") {
+    const { token, expires, ...rest } = data;
+    return {
+      ...rest,
+      id: `${String(data.identifier)}:${String(token)}`,
+      value: token,
+      expiresAt: expires
+    };
+  }
+  if (model === "user") {
+    return { ...data, emailVerified: data.emailVerified instanceof Date };
+  }
+  return data;
+}
+function storageField(model, field, value) {
+  if (model === "session") {
+    if (field === "token" || field === "id")
+      return ["sessionToken", value];
+    if (field === "expiresAt")
+      return ["expires", value];
+  }
+  if (model === "account") {
+    if (field === "providerId")
+      return ["provider", value];
+    if (field === "accountId")
+      return ["providerAccountId", value];
+    if (field === "id" && typeof value === "string") {
+      const separator = value.indexOf(":");
+      return separator < 0 ? ["providerAccountId", value] : ["providerAccountId", value.slice(separator + 1)];
+    }
+    return [accountFields[field] ?? field, value];
+  }
+  if (model === "verification") {
+    if (field === "value")
+      return ["token", value];
+    if (field === "expiresAt")
+      return ["expires", value];
+  }
+  if (model === "user" && field === "emailVerified" && typeof value === "boolean") {
+    return ["emailVerified", value ? /* @__PURE__ */ new Date(0) : null];
+  }
+  return [field, value];
+}
+function predicate(table, model, where) {
+  const expressions = where.map((condition) => {
+    if (model === "account" && condition.field === "id" && typeof condition.value === "string" && condition.value.includes(":")) {
+      const separator = condition.value.indexOf(":");
+      const provider = table["provider"];
+      const providerAccountId = table["providerAccountId"];
+      return and(
+        eq(provider, condition.value.slice(0, separator)),
+        eq(providerAccountId, condition.value.slice(separator + 1))
+      );
+    }
+    const [field, value] = storageField(model, condition.field, condition.value);
+    const column = table[field];
+    switch (condition.operator) {
+      case "ne":
+        return ne(column, value);
+      case "lt":
+        return lt(column, value);
+      case "lte":
+        return lte(column, value);
+      case "gt":
+        return gt(column, value);
+      case "gte":
+        return gte(column, value);
+      case "in":
+        return inArray(column, value);
+      case "not_in":
+        return notInArray(column, value);
+      case "contains":
+        return like(column, `%${String(value)}%`);
+      case "starts_with":
+        return like(column, `${String(value)}%`);
+      case "ends_with":
+        return like(column, `%${String(value)}`);
+      default:
+        return eq(column, value);
+    }
+  });
+  if (!expressions.length)
+    return void 0;
+  const groups = [];
+  let current = [];
+  for (let index = 0; index < expressions.length; index++) {
+    current.push(expressions[index]);
+    if (where[index]?.connector === "OR") {
+      groups.push(and(...current));
+      current = [];
+    }
+  }
+  if (current.length)
+    groups.push(and(...current));
+  return groups.length === 1 ? groups[0] : or(...groups);
+}
+function courseBuilderBetterAuthAdapter(options) {
+  const { db, tables } = options;
+  return createAdapterFactory({
+    config: {
+      adapterId: "coursebuilder",
+      adapterName: "Course Builder",
+      debugLogs: options.debugLogs ?? false,
+      supportsDates: true,
+      supportsBooleans: true,
+      supportsJSON: true,
+      supportsNumericIds: false,
+      transaction: false
+    },
+    adapter: ({ getDefaultModelName }) => {
+      const resolve = (model) => {
+        const canonical = getDefaultModelName(model);
+        const table = tables[canonical];
+        if (!table)
+          throw new Error(`Unsupported Better Auth model: ${model}`);
+        return { canonical, table };
+      };
+      return {
+        create: async ({ model, data }) => {
+          const { canonical, table } = resolve(model);
+          await db.insert(table).values(toStorage(canonical, data));
+          return data;
+        },
+        findOne: async ({ model, where, join }) => {
+          const { canonical, table } = resolve(model);
+          const [row] = await db.select().from(table).where(predicate(table, canonical, where)).limit(1);
+          if (!row)
+            return null;
+          const result = fromStorage(canonical, row);
+          if (canonical === "session" && join?.user) {
+            const userId = tables.user["id"];
+            const [user] = await db.select().from(tables.user).where(eq(userId, row.userId)).limit(1);
+            if (user)
+              result.user = fromStorage("user", user);
+          }
+          return result;
+        },
+        findMany: async ({ model, where, limit, offset, sortBy }) => {
+          const { canonical, table } = resolve(model);
+          let query = db.select().from(table).$dynamic();
+          const filter = where ? predicate(table, canonical, where) : void 0;
+          if (filter)
+            query = query.where(filter);
+          if (sortBy) {
+            const [field] = storageField(canonical, sortBy.field, null);
+            const column = table[field];
+            query = query.orderBy(
+              sortBy.direction === "asc" ? asc(column) : desc(column)
+            );
+          }
+          const rows = await query.limit(limit).offset(offset ?? 0);
+          return rows.map((row) => fromStorage(canonical, row));
+        },
+        update: async ({ model, where, update }) => {
+          const { canonical, table } = resolve(model);
+          await db.update(table).set(
+            toStorage(canonical, update)
+          ).where(predicate(table, canonical, where));
+          const [row] = await db.select().from(table).where(predicate(table, canonical, where)).limit(1);
+          return row ? fromStorage(canonical, row) : null;
+        },
+        updateMany: async ({ model, where, update }) => {
+          const { canonical, table } = resolve(model);
+          const result = await db.update(table).set(toStorage(canonical, update)).where(predicate(table, canonical, where));
+          return Number(result[0].affectedRows);
+        },
+        delete: async ({ model, where }) => {
+          const { canonical, table } = resolve(model);
+          await db.delete(table).where(predicate(table, canonical, where));
+        },
+        deleteMany: async ({ model, where }) => {
+          const { canonical, table } = resolve(model);
+          const result = await db.delete(table).where(predicate(table, canonical, where));
+          return Number(result[0].affectedRows);
+        },
+        count: async ({ model, where }) => {
+          const { canonical, table } = resolve(model);
+          const [result] = await db.select({ count: count() }).from(table).where(where ? predicate(table, canonical, where) : void 0);
+          return Number(result?.count ?? 0);
+        }
+      };
+    }
+  });
+}
+export {
+  courseBuilderBetterAuthAdapter
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@coursebuilder/better-auth",
+  "version": "0.1.0-canary.0.0c9beb2ae",
+  "private": false,
+  "description": "Better Auth database adapter for existing Course Builder MySQL tables",
+  "license": "ISC",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "better-auth": "1.6.23",
+    "drizzle-orm": "0.36.0"
+  },
+  "devDependencies": {
+    "drizzle-kit": "0.27.2",
+    "mysql2": "^3.6.1",
+    "tsup": "8.0.2",
+    "tsx": "^4.7.1",
+    "typescript": "5.4.5",
+    "vitest": "1.6.0",
+    "@coursebuilder/adapter-drizzle": "3.0.0-canary.0.0c9beb2ae"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "test": "pnpm test:mysql",
+    "test:mysql": "bash test/mysql/test.sh",
+    "test:mysql:ci": "bash test/mysql/test.sh ci",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,358 @@
+import {
+	createAdapterFactory,
+	type DBAdapterDebugLogOption,
+} from 'better-auth/adapters'
+import {
+	and,
+	asc,
+	count,
+	desc,
+	eq,
+	gt,
+	gte,
+	inArray,
+	like,
+	lt,
+	lte,
+	ne,
+	notInArray,
+	or,
+	type SQL,
+} from 'drizzle-orm'
+import type { MySqlDatabase, MySqlTable } from 'drizzle-orm/mysql-core'
+
+export type CourseBuilderBetterAuthTables = {
+	user: MySqlTable
+	session: MySqlTable
+	account: MySqlTable
+	verification: MySqlTable
+}
+
+export type CourseBuilderBetterAuthAdapterOptions = {
+	db: InstanceType<typeof MySqlDatabase>
+	tables: CourseBuilderBetterAuthTables
+	debugLogs?: DBAdapterDebugLogOption
+}
+
+type Where = {
+	field: string
+	operator: string
+	value: unknown
+	connector: 'AND' | 'OR'
+	mode: 'sensitive' | 'insensitive'
+}
+
+const accountFields: Record<string, string> = {
+	accessToken: 'access_token',
+	accessTokenExpiresAt: 'expires_at',
+	idToken: 'id_token',
+	refreshToken: 'refresh_token',
+	refreshTokenExpiresAt: 'refresh_token_expires_in',
+	tokenType: 'token_type',
+	sessionState: 'session_state',
+}
+
+function accountId(record: Record<string, unknown>) {
+	return `${String(record.provider)}:${String(record.providerAccountId)}`
+}
+
+function toEpochSeconds(value: unknown) {
+	return value instanceof Date ? Math.floor(value.getTime() / 1000) : value
+}
+
+function fromEpochSeconds(value: unknown) {
+	return typeof value === 'number' ? new Date(value * 1000) : value
+}
+
+function toStorage(model: string, data: Record<string, unknown>) {
+	if (model === 'session') {
+		const { token, expiresAt, ...rest } = data
+		return { ...rest, sessionToken: token, expires: expiresAt }
+	}
+	if (model === 'account') {
+		const { id: _id, providerId, accountId: providerAccountId, ...rest } = data
+		return Object.fromEntries(
+			Object.entries({ ...rest, provider: providerId, providerAccountId })
+				.filter(([key]) => key !== 'createdAt' && key !== 'updatedAt')
+				.map(([key, value]) => [
+					accountFields[key] ?? key,
+					key === 'accessTokenExpiresAt' || key === 'refreshTokenExpiresAt'
+						? toEpochSeconds(value)
+						: value,
+				]),
+		)
+	}
+	if (model === 'verification') {
+		const { value, expiresAt, id: _id, ...rest } = data
+		return { ...rest, token: value, expires: expiresAt }
+	}
+	if (model === 'user') {
+		const { updatedAt: _updatedAt, ...rest } = data
+		return {
+			...rest,
+			emailVerified: data.emailVerified ? new Date() : null,
+		}
+	}
+	return data
+}
+
+function fromStorage(model: string, data: Record<string, unknown>) {
+	if (model === 'session') {
+		const { sessionToken, expires, ...rest } = data
+		return {
+			...rest,
+			id: sessionToken,
+			token: sessionToken,
+			expiresAt: expires,
+		}
+	}
+	if (model === 'account') {
+		const translated = Object.fromEntries(
+			Object.entries(data).map(([key, value]) => {
+				const field =
+					Object.entries(accountFields).find(
+						([, storage]) => storage === key,
+					)?.[0] ?? key
+				return [
+					field,
+					field === 'accessTokenExpiresAt' || field === 'refreshTokenExpiresAt'
+						? fromEpochSeconds(value)
+						: value,
+				]
+			}),
+		)
+		return {
+			...translated,
+			id: accountId(data),
+			providerId: data.provider,
+			accountId: data.providerAccountId,
+		}
+	}
+	if (model === 'verification') {
+		const { token, expires, ...rest } = data
+		return {
+			...rest,
+			id: `${String(data.identifier)}:${String(token)}`,
+			value: token,
+			expiresAt: expires,
+		}
+	}
+	if (model === 'user') {
+		return { ...data, emailVerified: data.emailVerified instanceof Date }
+	}
+	return data
+}
+
+function storageField(model: string, field: string, value: unknown) {
+	if (model === 'session') {
+		if (field === 'token' || field === 'id')
+			return ['sessionToken', value] as const
+		if (field === 'expiresAt') return ['expires', value] as const
+	}
+	if (model === 'account') {
+		if (field === 'providerId') return ['provider', value] as const
+		if (field === 'accountId') return ['providerAccountId', value] as const
+		if (field === 'id' && typeof value === 'string') {
+			const separator = value.indexOf(':')
+			return separator < 0
+				? (['providerAccountId', value] as const)
+				: (['providerAccountId', value.slice(separator + 1)] as const)
+		}
+		return [accountFields[field] ?? field, value] as const
+	}
+	if (model === 'verification') {
+		if (field === 'value') return ['token', value] as const
+		if (field === 'expiresAt') return ['expires', value] as const
+	}
+	if (
+		model === 'user' &&
+		field === 'emailVerified' &&
+		typeof value === 'boolean'
+	) {
+		return ['emailVerified', value ? new Date(0) : null] as const
+	}
+	return [field, value] as const
+}
+
+function predicate(table: MySqlTable, model: string, where: Where[]) {
+	const expressions = where.map((condition) => {
+		if (
+			model === 'account' &&
+			condition.field === 'id' &&
+			typeof condition.value === 'string' &&
+			condition.value.includes(':')
+		) {
+			const separator = condition.value.indexOf(':')
+			const provider = table['provider' as keyof typeof table] as never
+			const providerAccountId = table[
+				'providerAccountId' as keyof typeof table
+			] as never
+			return and(
+				eq(provider, condition.value.slice(0, separator)),
+				eq(providerAccountId, condition.value.slice(separator + 1)),
+			)!
+		}
+		const [field, value] = storageField(model, condition.field, condition.value)
+		const column = table[field as keyof typeof table] as never
+		switch (condition.operator) {
+			case 'ne':
+				return ne(column, value as never)
+			case 'lt':
+				return lt(column, value as never)
+			case 'lte':
+				return lte(column, value as never)
+			case 'gt':
+				return gt(column, value as never)
+			case 'gte':
+				return gte(column, value as never)
+			case 'in':
+				return inArray(column, value as never[])
+			case 'not_in':
+				return notInArray(column, value as never[])
+			case 'contains':
+				return like(column, `%${String(value)}%`)
+			case 'starts_with':
+				return like(column, `${String(value)}%`)
+			case 'ends_with':
+				return like(column, `%${String(value)}`)
+			default:
+				return eq(column, value as never)
+		}
+	})
+	if (!expressions.length) return undefined
+	const groups: SQL[] = []
+	let current: SQL[] = []
+	for (let index = 0; index < expressions.length; index++) {
+		current.push(expressions[index]!)
+		if (where[index]?.connector === 'OR') {
+			groups.push(and(...current)!)
+			current = []
+		}
+	}
+	if (current.length) groups.push(and(...current)!)
+	return groups.length === 1 ? groups[0] : or(...groups)
+}
+
+/**
+ * Creates a Better Auth database adapter over Course Builder's existing MySQL
+ * auth tables. This is a translation boundary only and never creates schema.
+ *
+ * @param options - Existing Drizzle database and canonical CB auth tables.
+ * @returns A Better Auth database adapter factory.
+ *
+ * @example
+ * ```ts
+ * const database = courseBuilderBetterAuthAdapter({ db, tables })
+ * ```
+ */
+export function courseBuilderBetterAuthAdapter(
+	options: CourseBuilderBetterAuthAdapterOptions,
+): ReturnType<typeof createAdapterFactory> {
+	const { db, tables } = options
+	return createAdapterFactory({
+		config: {
+			adapterId: 'coursebuilder',
+			adapterName: 'Course Builder',
+			debugLogs: options.debugLogs ?? false,
+			supportsDates: true,
+			supportsBooleans: true,
+			supportsJSON: true,
+			supportsNumericIds: false,
+			transaction: false,
+		},
+		adapter: ({ getDefaultModelName }) => {
+			const resolve = (model: string) => {
+				const canonical = getDefaultModelName(model) as keyof typeof tables
+				const table = tables[canonical]
+				if (!table) throw new Error(`Unsupported Better Auth model: ${model}`)
+				return { canonical, table }
+			}
+			return {
+				create: async ({ model, data }) => {
+					const { canonical, table } = resolve(model)
+					await db.insert(table).values(toStorage(canonical, data) as never)
+					return data
+				},
+				findOne: async ({ model, where, join }) => {
+					const { canonical, table } = resolve(model)
+					const [row] = await db
+						.select()
+						.from(table)
+						.where(predicate(table, canonical, where))
+						.limit(1)
+					if (!row) return null
+					const result = fromStorage(canonical, row)
+					if (canonical === 'session' && join?.user) {
+						const userId = tables.user[
+							'id' as keyof typeof tables.user
+						] as never
+						const [user] = await db
+							.select()
+							.from(tables.user)
+							.where(eq(userId, row.userId as never))
+							.limit(1)
+						if (user) result.user = fromStorage('user', user)
+					}
+					return result as never
+				},
+				findMany: async ({ model, where, limit, offset, sortBy }) => {
+					const { canonical, table } = resolve(model)
+					let query = db.select().from(table).$dynamic()
+					const filter = where ? predicate(table, canonical, where) : undefined
+					if (filter) query = query.where(filter)
+					if (sortBy) {
+						const [field] = storageField(canonical, sortBy.field, null)
+						const column = table[field as keyof typeof table] as never
+						query = query.orderBy(
+							sortBy.direction === 'asc' ? asc(column) : desc(column),
+						)
+					}
+					const rows = await query.limit(limit).offset(offset ?? 0)
+					return rows.map((row) => fromStorage(canonical, row)) as never
+				},
+				update: async ({ model, where, update }) => {
+					const { canonical, table } = resolve(model)
+					await db
+						.update(table)
+						.set(
+							toStorage(canonical, update as Record<string, unknown>) as never,
+						)
+						.where(predicate(table, canonical, where))
+					const [row] = await db
+						.select()
+						.from(table)
+						.where(predicate(table, canonical, where))
+						.limit(1)
+					return row ? (fromStorage(canonical, row) as never) : null
+				},
+				updateMany: async ({ model, where, update }) => {
+					const { canonical, table } = resolve(model)
+					const result = await db
+						.update(table)
+						.set(toStorage(canonical, update) as never)
+						.where(predicate(table, canonical, where))
+					return Number((result as [{ affectedRows: number }])[0].affectedRows)
+				},
+				delete: async ({ model, where }) => {
+					const { canonical, table } = resolve(model)
+					await db.delete(table).where(predicate(table, canonical, where))
+				},
+				deleteMany: async ({ model, where }) => {
+					const { canonical, table } = resolve(model)
+					const result = await db
+						.delete(table)
+						.where(predicate(table, canonical, where))
+					return Number((result as [{ affectedRows: number }])[0].affectedRows)
+				},
+				count: async ({ model, where }) => {
+					const { canonical, table } = resolve(model)
+					const [result] = await db
+						.select({ count: count() })
+						.from(table)
+						.where(where ? predicate(table, canonical, where) : undefined)
+					return Number(result?.count ?? 0)
+				},
+			}
+		},
+	})
+}