surreal-better-auth 0.1.0

package/.github/workflows/ci.yaml

@@ -0,0 +1,59 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: Run Tests with SurrealDB
+    runs-on: ubuntu-latest
+
+    steps:
+      # Checkout code
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      # Setup SurrealDB
+      - name: Start SurrealDB
+        uses: surrealdb/setup-surreal@v2
+        with:
+          surrealdb_version: latest
+          surrealdb_port: 8000
+          surrealdb_username: root
+          surrealdb_password: root
+          surrealdb_auth: false
+          surrealdb_strict: false
+          surrealdb_log: info
+          surrealdb_additional_args: --allow-all
+          surrealdb_retry_count: 30
+      # Checkout code
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Setup Bun
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+
+      # Install dependencies
+      - name: Install dependencies
+        run: bun install
+
+      # Wait for SurrealDB
+      - name: Wait for SurrealDB
+        run: |
+          echo "Waiting for SurrealDB to become healthy..."
+          until curl --fail http://localhost:8000/status; do
+            echo "Waiting for SurrealDB..."
+            sleep 1
+          done
+          echo "SurrealDB is up and running!"
+
+      # Run tests
+      - name: Run tests
+        run: bun test
+
+      # Stop SurrealDB and cleanup
+      - name: Stop SurrealDB
+        if: always()
+        run: echo "Cleaning up... SurrealDB service will stop automatically."

package/.github/workflows/release.yaml

@@ -0,0 +1,79 @@
+name: Release
+
+on:
+  workflow_run:
+    workflows:
+      - ci
+    types:
+      - completed
+
+jobs:
+  release:
+    name: Create Release
+    runs-on: ubuntu-latest
+
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+
+    steps:
+      # Checkout code
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Setup Bun
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+
+      # Install dependencies
+      - name: Install dependencies
+        run: bun install
+
+      # Check version change
+      - name: Get current and previous version
+        id: version
+        run: |
+          PREV_VERSION=$(git tag --list --sort=-v:refname 'v*' | head -n 1 | sed 's/v//')
+          CURR_VERSION=$(node -p "require('./package.json').version")
+          echo "Previous Version: $PREV_VERSION"
+          echo "Current Version: $CURR_VERSION"
+          if [ "$PREV_VERSION" = "$CURR_VERSION" ]; then
+            echo "Version unchanged. Exiting..."
+            exit 1
+          fi
+          echo "version=$CURR_VERSION" >> $GITHUB_OUTPUT
+
+      # Generate Changelog
+      - name: Generate Changelog
+        id: changelog
+        uses: orhun/git-cliff-action@v2
+        with:
+          args: --output CHANGELOG.md
+        env:
+          GIT_CLIFF_CONFIG: |
+            [changelog]
+            header = "## Changelog"
+            footer = ""
+            trim = true
+
+            [commit-types]
+            feat = "✨ Features"
+            fix = "🐛 Bug Fixes"
+            docs = "📝 Documentation"
+            chore = "📦 Chores"
+            refactor = "♻️ Refactors"
+
+      # Create GitHub Release
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.version.outputs.version }}
+          name: Release v${{ steps.version.outputs.version }}
+          body_path: CHANGELOG.md
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      # Publish to npm
+      - name: Publish to npm
+        run: |
+          echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+          bun publish
+        env:
+          NPM_CONFIG_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1 @@
+[]

package/LICENSE

@@ -0,0 +1,17 @@
+The MIT License (MIT)
+Copyright (c) 2024 - present, Oskar Gmerek
+
+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/db/surreal.ts

@@ -0,0 +1,46 @@
+import Surreal from "surrealdb";
+
+// Define the database configuration interface
+interface DatabaseConfig {
+  url: string;
+  namespace: string;
+  database: string;
+  auth: {
+    username: string;
+    password: string;
+  };
+}
+
+// Define the default database configuration
+const DEFAULT_CONFIG: DatabaseConfig = {
+  url: "http://127.0.0.1:8000/rpc",
+  namespace: "better_auth",
+  database: "better_auth",
+  auth: {
+    username: "root",
+    password: "root",
+  },
+};
+
+// Define the function to get the database instance
+export async function getDatabase(
+  config: DatabaseConfig = DEFAULT_CONFIG,
+): Promise<Surreal> {
+  const db = new Surreal();
+
+  try {
+    await db.connect(config.url, {
+      namespace: config.namespace,
+      database: config.database,
+      auth: { username: config.auth.username, password: config.auth.password },
+    });
+    return db;
+  } catch (err) {
+    console.error(
+      "Failed to connect to SurrealDB:",
+      err instanceof Error ? err.message : String(err),
+    );
+    await db.close();
+    throw err;
+  }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "surreal-better-auth",
+  "version": "0.1.0",
+  "author": {
+    "name": "Oskar Gmerek",
+    "url": "https://oskargmerek.com",
+    "email": "oskar.gmerek@neetrio.com",
+    "github": "https://github.com/oskar-gmerek"
+  },
+  "description": "Better Auth adapter for SurrealDB",
+  "keywords": [
+    "adapter",
+    "auth",
+    "authentication",
+    "database",
+    "better-auth",
+    "better-auth-adapter",
+    "surrealdb",
+    "surrealdb-adapter",
+    "surrealdb-auth",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oskar-gmerek/surreal-better-auth.git"
+  },
+  "license": "MIT",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "@types/bun": "^1.1.14"
+  },
+  "peerDependencies": {
+    "better-auth": "^1.0.22",
+    "surrealdb": "^1.1.0",
+    "typescript": "^5.7.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,228 @@
+import type { Adapter, BetterAuthOptions, Where } from "better-auth/types";
+import { PreparedQuery, type Surreal } from "surrealdb";
+
+function composeWhereClause(where: Where[], model: string): string {
+  if (!where.length) return "";
+
+  return where
+    .map(({ field, value, operator = "eq", connector = "AND" }, index) => {
+      const val =
+        typeof value === "string" ? `'${value.replace(/'/g, "\\'")}'` : value;
+      const mod = `'${model.replace(/'/g, "\\'")}'`;
+
+      const condition = {
+        eq: () =>
+          field === "id"
+            ? `${field} = type::thing(${mod}, ${val})`
+            : `${field} = ${val}`,
+        in: () =>
+          field === "id"
+            ? `${field} IN [${
+                Array.isArray(val)
+                  ? val.map((v) => `type::thing('${model}', ${v})`).join(", ")
+                  : `type::thing('${model}', ${val})`
+              }]`
+            : `${field} IN [${
+                Array.isArray(value) ? value.map((v) => `${v}`).join(", ") : val
+              }]`,
+        gt: () => `${field} > ${val}`,
+        gte: () => `${field} >= ${val}`,
+        lt: () => `${field} < ${val}`,
+        lte: () => `${field} <= ${val}`,
+        ne: () => `${field} != ${val}`,
+        contains: () => `${field} CONTAINS ${val}`,
+        starts_with: () => `string::starts_with(${field}, ${val})`,
+        ends_with: () => `string::ends_with(${field}, ${val})`,
+      }[operator.toLowerCase() as typeof operator]();
+
+      return index > 0 ? `${connector} ${condition}` : condition;
+    })
+    .join(" ");
+}
+
+function checkForIdInWhereClause(
+  where: Where[],
+): string | number | boolean | string[] | number[] | undefined {
+  if (where.some(({ field }) => field === "id")) {
+    return where.find(({ field }) => field === "id")?.value;
+  }
+}
+
+export const surrealAdapter = (db: Surreal) => (options: BetterAuthOptions) => {
+  if (!db) {
+    throw new Error("SurrealDB adapter requires a SurrealDB client");
+  }
+  return {
+    id: "surrealdb",
+    async create(data) {
+      const { model, data: val } = data;
+
+      const query = new PreparedQuery(
+        `CREATE type::table($model) CONTENT $val `,
+        {
+          model: model,
+          val: val,
+        },
+      );
+
+      const response = await db.query<[any[]]>(query);
+      const result = response[0][0];
+      return result;
+    },
+    async findOne(data) {
+      const { model, where, select = [] } = data;
+
+      const wheres = composeWhereClause(where, model);
+
+      const query =
+        select.length > 0
+          ? new PreparedQuery(
+              `SELECT type::fields($selects) FROM IF $thing {type::thing($model, $thing)} ELSE {type::table($model)} WHERE $wheres;`,
+              {
+                id: select.includes("id")
+                  ? 'meta::id("id") as id, '
+                  : undefined,
+                thing: checkForIdInWhereClause(where) || undefined,
+                selects: select,
+                model: model,
+                wheres: wheres,
+              },
+            )
+          : new PreparedQuery(
+              `SELECT * FROM IF $thing {type::thing($model, $thing)} ELSE {type::table($model)} WHERE $wheres;`,
+              {
+                id: select.includes("id")
+                  ? 'meta::id("id") as id, '
+                  : undefined,
+                thing: checkForIdInWhereClause(where) || undefined,
+                model: model,
+                wheres: wheres,
+              },
+            );
+
+      const response = await db.query<[any[]]>(query);
+      const result = response[0][0];
+
+      if (!result) {
+        return null;
+      }
+
+      return result;
+    },
+    async findMany(data) {
+      const { model, where, limit, offset, sortBy } = data;
+      const clauses: string[] = [];
+
+      if (where) {
+        const wheres = composeWhereClause(where, model);
+        clauses.push(`WHERE ${wheres}`);
+      }
+      if (sortBy !== undefined) {
+        clauses.push(`ORDER BY ${sortBy.field} ${sortBy.direction}`);
+      }
+      if (limit !== undefined) {
+        clauses.push(`LIMIT type::number('${limit}')`);
+      }
+      if (offset !== undefined) {
+        clauses.push(`START type::number('${offset}')`);
+      }
+
+      const query = new PreparedQuery(
+        `SELECT * FROM type::table($model) ${
+          clauses.length > 0 ? clauses.join(" ") : ""
+        }`,
+        {
+          model: model,
+        },
+      );
+
+      const response = await db.query<[any[]]>(query);
+      const result = response[0];
+
+      return result;
+    },
+    async update(data) {
+      const { model, where, update } = data;
+      const wheres = composeWhereClause(where, model);
+      if (!wheres)
+        throw new Error("Empty conditions - possible unintended operation");
+
+      if (update.id) {
+        update.id = undefined;
+      }
+
+      const query = new PreparedQuery(
+        "UPDATE type::table($model) MERGE { $update } WHERE $wheres",
+        {
+          model: model,
+          update: update,
+          wheres: wheres,
+        },
+      );
+
+      const response = await db.query<[any[]]>(query);
+      const result = response[0][0];
+
+      return result;
+    },
+    async updateMany(data) {
+      const { model, where, update } = data;
+      const wheres = composeWhereClause(where, model);
+      if (!wheres)
+        throw new Error("Empty conditions - possible unintended operation");
+
+      if (update.id) {
+        update.id = undefined;
+      }
+
+      const query = new PreparedQuery(
+        "UPDATE type::table($model) MERGE { $update } WHERE $wheres",
+        {
+          model: model,
+          update: update,
+          wheres: wheres,
+        },
+      );
+
+      const response = await db.query<[any[]]>(query);
+      const result = response[0];
+
+      return result.length;
+    },
+    async delete(data) {
+      const { model, where } = data;
+      const wheres = composeWhereClause(where, model);
+      if (!wheres)
+        throw new Error("Empty conditions - possible unintended operation");
+
+      const query = new PreparedQuery(
+        `DELETE type::table($model) WHERE ${wheres}`,
+        {
+          model: model,
+          wheres: wheres,
+        },
+      );
+
+      await db.query(query);
+    },
+    async deleteMany(data) {
+      const { model, where } = data;
+      const wheres = composeWhereClause(where, model);
+      if (!wheres)
+        throw new Error("Empty conditions - possible unintended operation");
+
+      const query = new PreparedQuery(
+        `DELETE type::table($model) WHERE ${wheres}`,
+        {
+          model: model,
+          wheres: wheres,
+        },
+      );
+
+      const response = await db.query<[any[]]>(query);
+      const result = response[0];
+
+      return result.length;
+    },
+  } satisfies Adapter;
+};

package/tests/runAdapterTest.ts

@@ -0,0 +1,443 @@
+import { expect, test } from "bun:test";
+import { generateId } from "better-auth";
+import type { Adapter, BetterAuthOptions, User } from "better-auth/types";
+
+interface AdapterTestOptions {
+	getAdapter: (
+		customOptions?: Omit<BetterAuthOptions, "database">,
+	) => Promise<Adapter>;
+	skipGenerateIdTest?: boolean;
+}
+
+export async function runAdapterTest(opts: AdapterTestOptions) {
+	const adapter = await opts.getAdapter();
+	const user = {
+		id: "1",
+		name: "user",
+		email: "user@email.com",
+		emailVerified: true,
+		createdAt: new Date(),
+		updatedAt: new Date(),
+	};
+
+	test("create model", async () => {
+		const res = await adapter.create({
+			model: "user",
+			data: user,
+		});
+
+		expect({
+			name: res.name,
+			email: res.email,
+		}).toEqual({
+			name: user.name,
+			email: user.email,
+		});
+		user.id = res.id;
+	});
+
+	test("find model", async () => {
+		const res = await adapter.findOne<User>({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: user.id,
+				},
+			],
+		});
+		expect({
+			name: res?.name,
+			email: res?.email,
+		}).toEqual({
+			name: user.name,
+			email: user.email,
+		});
+	});
+
+	test("find model without id", async () => {
+		const res = await adapter.findOne<User>({
+			model: "user",
+			where: [
+				{
+					field: "email",
+					value: user.email,
+				},
+			],
+		});
+		expect({
+			name: res?.name,
+			email: res?.email,
+		}).toEqual({
+			name: user.name,
+			email: user.email,
+		});
+	});
+
+	test("find model with select", async () => {
+		const res = await adapter.findOne({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: user.id,
+				},
+			],
+			select: ["email"],
+		});
+		expect(res).toEqual({ email: user.email });
+	});
+
+	test("update model", async () => {
+		const newEmail = "updated@email.com";
+
+		const res = await adapter.update<User>({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: user.id,
+				},
+			],
+			update: {
+				email: newEmail,
+			},
+		});
+		expect(res).toMatchObject({
+			email: newEmail,
+			name: user.name,
+		});
+	});
+
+	test("should find many", async () => {
+		const res = await adapter.findMany({
+			model: "user",
+		});
+		expect(res.length).toBe(1);
+	});
+
+	test("should find many with where", async () => {
+		const user = await adapter.create<User>({
+			model: "user",
+			data: {
+				id: "2",
+				name: "user2",
+				email: "test@email.com",
+				emailVerified: true,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		const res = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: user.id,
+				},
+			],
+		});
+		expect(res.length).toBe(1);
+	});
+
+	test("should find many with operators", async () => {
+		const newUser = await adapter.create<User>({
+			model: "user",
+			data: {
+				id: "3",
+				name: "user",
+				email: "test-email2@email.com",
+				emailVerified: true,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		const res = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					operator: "in",
+					value: [user.id, newUser.id],
+				},
+			],
+		});
+		expect(res.length).toBe(2);
+	});
+
+	test("should work with reference fields", async () => {
+		const user = await adapter.create<{ id: string } & Record<string, any>>({
+			model: "user",
+			data: {
+				id: "4",
+				name: "user",
+				email: "my-email@email.com",
+				emailVerified: true,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		await adapter.create({
+			model: "session",
+			data: {
+				id: "1",
+				token: generateId(),
+				createdAt: new Date(),
+				updatedAt: new Date(),
+				userId: user.id,
+				expiresAt: new Date(),
+			},
+		});
+		const res = await adapter.findOne({
+			model: "session",
+			where: [
+				{
+					field: "userId",
+					value: user.id,
+				},
+			],
+		});
+		expect(res).toMatchObject({
+			userId: user.id,
+		});
+	});
+
+	test("should find many with sortBy", async () => {
+		await adapter.create({
+			model: "user",
+			data: {
+				id: "5",
+				name: "a",
+				email: "a@email.com",
+				emailVerified: true,
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+		const res = await adapter.findMany<User>({
+			model: "user",
+			sortBy: {
+				field: "name",
+				direction: "asc",
+			},
+		});
+		expect(res[0].name).toBe("a");
+
+		const res2 = await adapter.findMany<User>({
+			model: "user",
+			sortBy: {
+				field: "name",
+				direction: "desc",
+			},
+		});
+
+		expect(res2[res2.length - 1].name).toBe("a");
+	});
+
+	test("should find many with limit", async () => {
+		const res = await adapter.findMany({
+			model: "user",
+			limit: 1,
+		});
+		expect(res.length).toBe(1);
+	});
+
+	test("should find many with offset", async () => {
+		const res = await adapter.findMany({
+			model: "user",
+			offset: 2,
+		});
+		expect(res.length).toBe(3);
+	});
+
+	test("should update with multiple where", async () => {
+		await adapter.updateMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					value: user.name,
+				},
+				{
+					field: "email",
+					value: user.email,
+				},
+			],
+			update: {
+				email: "updated@email.com",
+			},
+		});
+		const updatedUser = await adapter.findOne<User>({
+			model: "user",
+			where: [
+				{
+					field: "email",
+					value: "updated@email.com",
+				},
+			],
+		});
+		expect(updatedUser).toMatchObject({
+			name: user.name,
+			email: "updated@email.com",
+		});
+	});
+
+	test("delete model", async () => {
+		await adapter.delete({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: user.id,
+				},
+			],
+		});
+		const findRes = await adapter.findOne({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: user.id,
+				},
+			],
+		});
+		expect(findRes).toBeNull();
+	});
+
+	test("should delete many", async () => {
+		for (const id of ["to-be-delete1", "to-be-delete2", "to-be-delete3"]) {
+			await adapter.create({
+				model: "user",
+				data: {
+					id,
+					name: "to-be-deleted",
+					email: `email@test-${id}.com`,
+					emailVerified: true,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+		}
+		const findResFirst = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					value: "to-be-deleted",
+				},
+			],
+		});
+		expect(findResFirst.length).toBe(3);
+		await adapter.deleteMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					value: "to-be-deleted",
+				},
+			],
+		});
+		const findRes = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					value: "to-be-deleted",
+				},
+			],
+		});
+		expect(findRes.length).toBe(0);
+	});
+
+	test("shouldn't throw on delete record not found", async () => {
+		await adapter.delete({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: "5",
+				},
+			],
+		});
+	});
+
+	test("shouldn't throw on record not found", async () => {
+		const res = await adapter.findOne({
+			model: "user",
+			where: [
+				{
+					field: "id",
+					value: "5",
+				},
+			],
+		});
+		expect(res).toBeNull();
+	});
+
+	test("should find many with contains operator", async () => {
+		const res = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					operator: "contains",
+					value: "user2",
+				},
+			],
+		});
+		expect(res.length).toBe(1);
+	});
+
+	test("should search users with startsWith", async () => {
+		const res = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					operator: "starts_with",
+					value: "us",
+				},
+			],
+		});
+		expect(res.length).toBe(3);
+	});
+
+	test("should search users with endsWith", async () => {
+		const res = await adapter.findMany({
+			model: "user",
+			where: [
+				{
+					field: "name",
+					operator: "ends_with",
+					value: "er2",
+				},
+			],
+		});
+		expect(res.length).toBe(1);
+	});
+
+	test.skipIf(opts.skipGenerateIdTest || false)(
+		"should prefer generateId if provided",
+		async () => {
+			const customAdapter = await opts.getAdapter({
+				advanced: {
+					generateId: () => "mocked-id",
+				},
+			});
+
+			const res = await customAdapter.create({
+				model: "user",
+				data: {
+					id: "1",
+					name: "user4",
+					email: "user4@email.com",
+					emailVerified: true,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			});
+
+			expect(res.id).toBe("mocked-id");
+		},
+	);
+}

package/tests/surreal-adapter.test.ts

@@ -0,0 +1,94 @@
+import { beforeAll, describe, expect, it } from "bun:test";
+import { surrealAdapter } from "../src";
+import { getDatabase } from "../db/surreal";
+import { runAdapterTest } from "./runAdapterTest";
+import { getTestInstance } from "./testInstance";
+
+describe("adapter test", async () => {
+  const db = await getDatabase();
+
+  async function setupDB() {
+    await db.query(
+      `
+      DEFINE NAMESPACE IF NOT EXISTS better_auth;
+      DEFINE DATABASE IF NOT EXISTS better_auth;
+      DELETE user;
+      DELETE session
+      `,
+    );
+  }
+
+  beforeAll(async () => {
+    await setupDB();
+  });
+
+  const adapter = surrealAdapter(db);
+  await runAdapterTest({
+    getAdapter: async (customOptions = {}) => {
+      return adapter({
+        user: {
+          fields: {
+            email: "email_address",
+          },
+          additionalFields: {
+            test: {
+              type: "string",
+              defaultValue: "test",
+            },
+          },
+        },
+        session: {
+          modelName: "sessions",
+        },
+        ...customOptions,
+      });
+    },
+    skipGenerateIdTest: true,
+  });
+});
+
+describe("simple-flow", async () => {
+  const { auth, client, sessionSetter } = await getTestInstance(
+    {},
+    {
+      disableTestUser: true,
+      testWith: "surreal",
+    },
+  );
+  const testUser = {
+    email: "test-eamil@email.com",
+    password: "password",
+    name: "Test Name",
+  };
+
+  it("should sign up", async () => {
+    const user = await auth.api.signUpEmail({
+      body: testUser,
+    });
+    expect(user).toBeDefined();
+  });
+
+  it("should sign in", async () => {
+    const user = await auth.api.signInEmail({
+      body: testUser,
+    });
+    expect(user).toBeDefined();
+  });
+
+  it("should get session", async () => {
+    const headers = new Headers();
+    await client.signIn.email(
+      {
+        email: testUser.email,
+        password: testUser.password,
+      },
+      {
+        onSuccess: sessionSetter(headers),
+      },
+    );
+    const { data: session } = await client.getSession({
+      fetchOptions: { headers },
+    });
+    expect(session?.user).toBeDefined();
+  });
+});

package/tests/testInstance.ts

@@ -0,0 +1,222 @@
+import { afterAll } from "bun:test";
+import type { SuccessContext } from "@better-fetch/fetch";
+import { betterAuth } from "better-auth";
+import { createAuthClient } from "better-auth/client";
+import { parseSetCookieHeader } from "better-auth/cookies";
+import { getAdapter } from "better-auth/db";
+import type {
+  BetterAuthOptions,
+  ClientOptions,
+  Session,
+  User,
+} from "better-auth/types";
+
+import { getBaseURL } from "../utlis/getBaseURL";
+
+import { surrealAdapter } from "..";
+import { getDatabase } from "../db/surreal";
+
+export async function getTestInstance<
+  O extends Partial<BetterAuthOptions>,
+  C extends ClientOptions,
+>(
+  options?: O,
+  config?: {
+    clientOptions?: C;
+    port?: number;
+    disableTestUser?: boolean;
+    testUser?: Partial<User>;
+    testWith?: "surreal";
+  },
+) {
+  const db = await getDatabase({
+    url: "http://127.0.0.1:8000/rpc",
+    namespace: "better_auth_test",
+    database: "better_auth_test",
+    auth: { username: "root", password: "root" },
+  });
+
+  const opts = {
+    socialProviders: {
+      github: {
+        clientId: "test",
+        clientSecret: "test",
+      },
+      google: {
+        clientId: "test",
+        clientSecret: "test",
+      },
+    },
+    secret: "better-auth.secret",
+    database: surrealAdapter(db),
+    emailAndPassword: {
+      enabled: true,
+    },
+    rateLimit: {
+      enabled: false,
+    },
+    advanced: {
+      cookies: {},
+    },
+  } satisfies BetterAuthOptions;
+
+  const auth = betterAuth({
+    baseURL: `http://localhost:${config?.port || 3000}`,
+    ...opts,
+    ...options,
+    advanced: {
+      disableCSRFCheck: true,
+      ...options?.advanced,
+    },
+  } as O extends undefined ? typeof opts : O & typeof opts);
+
+  const testUser = {
+    email: "test@test.com",
+    password: "test123456",
+    name: "test user",
+    ...config?.testUser,
+  };
+  async function createTestUser() {
+    if (config?.disableTestUser) {
+      return;
+    }
+    //@ts-expect-error
+    await auth.api.signUpEmail({
+      body: testUser,
+    });
+  }
+
+  await createTestUser();
+
+  afterAll(async () => {
+    await db.query("DELETE account; DELETE session; DELETE user;");
+    return;
+  });
+
+  async function signInWithTestUser() {
+    if (config?.disableTestUser) {
+      throw new Error("Test user is disabled");
+    }
+    const headers = new Headers();
+    const setCookie = (name: string, value: string) => {
+      const current = headers.get("cookie");
+      headers.set("cookie", `${current || ""}; ${name}=${value}`);
+    };
+    //@ts-expect-error
+    const { data } = await client.signIn.email({
+      email: testUser.email,
+      password: testUser.password,
+
+      fetchOptions: {
+        // @ts-expect-error
+        onSuccess(context) {
+          const header = context.response.headers.get("set-cookie");
+          const cookies = parseSetCookieHeader(header || "");
+          const signedCookie = cookies.get("better-auth.session_token")?.value;
+          headers.set("cookie", `better-auth.session_token=${signedCookie}`);
+        },
+      },
+    });
+    return {
+      session: data.session as Session,
+      user: data.user as User,
+      headers,
+      setCookie,
+    };
+  }
+  async function signInWithUser(email: string, password: string) {
+    const headers = new Headers();
+    //@ts-expect-error
+    const { data } = await client.signIn.email({
+      email,
+      password,
+      fetchOptions: {
+        //@ts-expect-error
+        onSuccess(context) {
+          const header = context.response.headers.get("set-cookie");
+          const cookies = parseSetCookieHeader(header || "");
+          const signedCookie = cookies.get("better-auth.session_token")?.value;
+          headers.set("cookie", `better-auth.session_token=${signedCookie}`);
+        },
+      },
+    });
+    return {
+      res: data as {
+        user: User;
+        session: Session;
+      },
+      headers,
+    };
+  }
+
+  const customFetchImpl = async (
+    url: string | URL | Request,
+    init?: RequestInit,
+  ) => {
+    const req = new Request(url.toString(), init);
+    return auth.handler(req);
+  };
+
+  function sessionSetter(headers: Headers) {
+    return (context: SuccessContext) => {
+      const header = context.response.headers.get("set-cookie");
+      if (header) {
+        const cookies = parseSetCookieHeader(header || "");
+        const signedCookie = cookies.get("better-auth.session_token")?.value;
+        headers.set("cookie", `better-auth.session_token=${signedCookie}`);
+      }
+    };
+  }
+  function cookieSetter(headers: Headers) {
+    return (context: { response: Response }) => {
+      const setCookieHeader = context.response.headers.get("set-cookie");
+      if (!setCookieHeader) {
+        return;
+      }
+
+      const cookieMap = new Map<string, string>();
+
+      const existingCookiesHeader = headers.get("cookie") || "";
+      existingCookiesHeader.split(";").forEach((cookie) => {
+        const [name, ...rest] = cookie.trim().split("=");
+        if (name && rest.length > 0) {
+          cookieMap.set(name, rest.join("="));
+        }
+      });
+
+      const setCookieHeaders = setCookieHeader.split(",");
+      setCookieHeaders.forEach((header) => {
+        const cookies = parseSetCookieHeader(header);
+        cookies.forEach((value, name) => {
+          cookieMap.set(name, value.value);
+        });
+      });
+
+      const updatedCookies = Array.from(cookieMap.entries())
+        .map(([name, value]) => `${name}=${value}`)
+        .join("; ");
+      headers.set("cookie", updatedCookies);
+    };
+  }
+  const client = createAuthClient({
+    ...(config?.clientOptions as C extends undefined ? {} : C),
+    baseURL: getBaseURL(
+      options?.baseURL || "http://localhost:" + (config?.port || 3000),
+      options?.basePath || "/api/auth",
+    ),
+    fetchOptions: {
+      customFetchImpl,
+    },
+  });
+  return {
+    auth,
+    client,
+    testUser,
+    signInWithTestUser,
+    signInWithUser,
+    cookieSetter,
+    customFetchImpl,
+    sessionSetter,
+    db: await getAdapter(auth.options),
+  };
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+	"compilerOptions": {
+		"target": "ES2021",
+		"module": "ES2022",
+		"moduleResolution": "node",
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"strict": true,
+		"skipLibCheck": true
+	}
+}

package/utlis/getBaseURL.ts

@@ -0,0 +1,32 @@
+import { BetterAuthError } from "better-auth";
+
+function checkHasPath(url: string): boolean {
+	try {
+		const parsedUrl = new URL(url);
+		return parsedUrl.pathname !== "/";
+	} catch (error) {
+		throw new BetterAuthError(
+			`Invalid base URL: ${url}. Please provide a valid base URL.`,
+		);
+	}
+}
+
+function withPath(url: string, path = "/api/auth") {
+	const hasPath = checkHasPath(url);
+	if (hasPath) {
+		return url;
+	}
+	path = path.startsWith("/") ? path : `/${path}`;
+	return `${url}${path}`;
+}
+
+export function getBaseURL(url?: string, path?: string) {
+	if (url) {
+		return withPath(url, path);
+	}
+
+	if (typeof window !== "undefined" && window.location) {
+		return withPath(window.location.origin, path);
+	}
+	return undefined;
+}