surreal-better-auth 0.1.0 → 0.2.1

package/README.md

@@ -0,0 +1,29 @@
+# Surreal Adapter for Better Auth
+This adapter allows you to use [SurrealDB](https://surrealist.app/referral?code=4pn5aba943lpbn8l) as a database for your [Better Auth](https://better-auth.com) implementation.
+
+## Feedback
+⭐ Found this project helpful? Show some love with a star and consider to be a [SPONSOR](https://github.com/sponsors/oskar-gmerek)! Your support keeps the code evolving. 🚀
+
+## Free Database
+✨✨✨ Grab [FREE SurrealDB Cloud instance + something extra](https://surrealist.app/referral?code=4pn5aba943lpbn8l) ✨✨✨
+
+## » Installation
+```bash
+bun add surreal-better-auth
+```
+
+## » Configuration
+```ts
+import { surrealAdapter } from 'surreal-better-auth'
+import { databaseInstance } from './your-surreal-singleton'
+
+...
+export const auth = betterAuth({
+...
+database: surrealAdapter(databaseInstance)
+...
+})
+```
+
+## ✨ Contributions
+Contributions are welcome! Please open an issue or a pull request if you have any suggestions or improvements.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "surreal-better-auth",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "author": {
     "name": "Oskar Gmerek",
     "url": "https://oskargmerek.com",
@@ -26,6 +26,11 @@
   },
   "license": "MIT",
   "main": "src/index.ts",
+  "files": [
+    "src/index.ts",
+    "README.md",
+    "LICENSE"
+  ],
   "devDependencies": {
     "@types/bun": "^1.1.14"
   },

package/.github/workflows/ci.yaml

@@ -1,59 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

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

package/db/surreal.ts

@@ -1,46 +0,0 @@
-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/tests/runAdapterTest.ts

@@ -1,443 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

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

package/utlis/getBaseURL.ts

@@ -1,32 +0,0 @@
-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;
-}